Function TestContentWriter

plugins/content/local/store_test.go:143–250

(t *testing.T)

}

func TestContentWriter(t *testing.T) {
	for _, alg := range []digest.Algorithm{digest.SHA256, digest.SHA512} {
		t.Run(alg.String(), func(t *testing.T) {
			ctx, tmpdir, cs, cleanup := contentStoreEnv(t)
			defer cleanup()
			defer testutil.DumpDirOnFailure(t, tmpdir)

			cw, err := cs.Writer(ctx, content.WithRef("myref"))
			if err != nil {
				t.Fatal(err)
			}
			if err := cw.Close(); err != nil {
				t.Fatal(err)
			}

			if _, err := os.Stat(filepath.Join(tmpdir, "ingest")); os.IsNotExist(err) {
				t.Fatal("ingest dir should be created", err)
			}

			// reopen, so we can test things
			cw, err = cs.Writer(ctx, content.WithRef("myref"))
			if err != nil {
				t.Fatal(err)
			}

			// make sure that second resume also fails
			if _, err = cs.Writer(ctx, content.WithRef("myref")); err == nil {
				// TODO(stevvooe): This also works across processes. Need to find a way
				// to test that, as well.
				t.Fatal("no error on second resume")
			}

			// we should also see this as an active ingestion
			ingestions, err := cs.ListStatuses(ctx, "")
			if err != nil {
				t.Fatal(err)
			}

			// clear out the time and meta cause we don't care for this test
			for i := range ingestions {
				ingestions[i].UpdatedAt = time.Time{}
				ingestions[i].StartedAt = time.Time{}
			}

			if !reflect.DeepEqual(ingestions, []content.Status{
				{
					Ref:    "myref",
					Offset: 0,
				},
			}) {
				t.Fatalf("unexpected ingestion set: %v", ingestions)
			}

			p := make([]byte, 4<<20)
			if _, err := rand.Read(p); err != nil {
				t.Fatal(err)
			}
			expected := alg.FromBytes(p)