func TestMergeLogChunks(t *testing.T) {
	mockdb := &database.MockDatabase{}

	// Merging log chunks not valid in following states
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.WAITING_FOR_UPLOAD}, mockdb, nil))
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.APPENDING}, mockdb, nil))
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.UPLOADED}, mockdb, nil))
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.UPLOADING}, mockdb, nil))

	// Closing an empty artifact with no errors
	mockdb.On("UpdateArtifact", &model.Artifact{
		State: model.CLOSED_WITHOUT_DATA,
	}).Return(nil).Once()
	assert.NoError(t, MergeLogChunks(&model.Artifact{State: model.APPEND_COMPLETE, Size: 0}, mockdb, nil))

	// Closing an empty artifact with db errors
	mockdb.On("UpdateArtifact", &model.Artifact{
		State: model.CLOSED_WITHOUT_DATA,
	}).Return(database.MockDatabaseError()).Once()
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.APPEND_COMPLETE, Size: 0}, mockdb, nil))

	// ----- BEGIN Closing an artifact with some log chunks
	// DB Error while updating artifact
	mockdb.On("UpdateArtifact", &model.Artifact{
		State: model.UPLOADING,
		Size:  10,
	}).Return(database.MockDatabaseError()).Once()
	assert.Error(t, MergeLogChunks(&model.Artifact{State: model.APPEND_COMPLETE, Size: 10}, mockdb, nil))

	// DB Error while fetching logchunks
	mockdb.On("UpdateArtifact", &model.Artifact{
		Id:    2,
		State: model.UPLOADING,
		Size:  10,
	}).Return(nil).Once()
	mockdb.On("ListLogChunksInArtifact", int64(2)).Return(nil, database.MockDatabaseError()).Once()
	assert.Error(t, MergeLogChunks(&model.Artifact{Id: 2, State: model.APPEND_COMPLETE, Size: 10}, mockdb, nil))

	// Stitching chunks and uploading to S3 successfully (but deleting logchunks fail)
	mockdb.On("UpdateArtifact", &model.Artifact{
		Id:       2,
		State:    model.UPLOADING,
		Size:     10,
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
	}).Return(nil).Once()
	mockdb.On("ListLogChunksInArtifact", int64(2)).Return([]model.LogChunk{
		model.LogChunk{Content: "01234"},
		model.LogChunk{Content: "56789"},
	}, nil).Once()
	mockdb.On("UpdateArtifact", &model.Artifact{
		Id:       2,
		State:    model.UPLOADED,
		S3URL:    "/TestMergeLogChunks__bucketName/TestMergeLogChunks__artifactName",
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
		Size:     10,
	}).Return(nil).Once()
	mockdb.On("DeleteLogChunksForArtifact", int64(2)).Return(int64(0), database.MockDatabaseError()).Once()
	s3Server, s3Bucket := createS3Bucket(t)
	assert.NoError(t, MergeLogChunks(&model.Artifact{
		Id:       2,
		State:    model.APPEND_COMPLETE,
		Size:     10,
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
	}, mockdb, s3Bucket))
	s3Server.Quit()

	// Stitching chunks and uploading to S3 successfully
	mockdb.On("UpdateArtifact", &model.Artifact{
		Id:       3,
		State:    model.UPLOADING,
		Size:     10,
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
	}).Return(nil).Once()
	mockdb.On("ListLogChunksInArtifact", int64(3)).Return([]model.LogChunk{
		model.LogChunk{Content: "01234"},
		model.LogChunk{Content: "56789"},
	}, nil).Once()
	mockdb.On("DeleteLogChunksForArtifact", int64(3)).Return(int64(2), nil).Once()
	mockdb.On("UpdateArtifact", &model.Artifact{
		Id:       3,
		State:    model.UPLOADED,
		S3URL:    "/TestMergeLogChunks__bucketName/TestMergeLogChunks__artifactName",
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
		Size:     10,
	}).Return(nil).Once()
	s3Server, s3Bucket = createS3Bucket(t)
	assert.NoError(t, MergeLogChunks(&model.Artifact{
		Id:       3,
		State:    model.APPEND_COMPLETE,
		Size:     10,
		Name:     "TestMergeLogChunks__artifactName",
		BucketId: "TestMergeLogChunks__bucketName",
	}, mockdb, s3Bucket))
	s3Server.Quit()
	// ----- END Closing an artifact with some log chunks
}
func TestAppendLogChunk(t *testing.T) {
	mockdb := &database.MockDatabase{}

	// Already completed artifact
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPEND_COMPLETE,
	}, nil))

	// Size 0 chunk
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
	}, &model.LogChunk{
		Size: 0,
	}))

	// Blank string chunk
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
	}, &model.LogChunk{
		Size:    1,
		Content: "",
	}))

	// Mismatch between size and content chunk
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
	}, &model.LogChunk{
		Size:    1,
		Content: "ab",
	}))

	logChunk := &model.LogChunk{
		Size:    2,
		Content: "ab",
	}

	// DB Error while trying to find where the next byte is expected
	mockdb.On("GetLastByteSeenForArtifact", int64(10)).Return(int64(0), database.MockDatabaseError()).Once()
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
		Id:    10,
	}, logChunk))

	mockdb.On("GetLastByteSeenForArtifact", int64(10)).Return(int64(2), nil).Once()
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
		Id:    10,
	}, logChunk))

	mockdb.On("GetLastByteSeenForArtifact", int64(10)).Return(int64(0), nil).Once()
	mockdb.On("UpdateArtifact", mock.AnythingOfType("*model.Artifact")).Return(database.MockDatabaseError()).Once()
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
		Id:    10,
	}, logChunk))

	mockdb.On("GetLastByteSeenForArtifact", int64(10)).Return(int64(0), nil).Once()
	mockdb.On("UpdateArtifact", mock.AnythingOfType("*model.Artifact")).Return(nil).Once()
	mockdb.On("InsertLogChunk", logChunk).Return(database.MockDatabaseError()).Once()
	assert.Error(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
		Id:    10,
	}, logChunk))

	mockdb.On("GetLastByteSeenForArtifact", int64(10)).Return(int64(0), nil).Once()
	mockdb.On("UpdateArtifact", mock.AnythingOfType("*model.Artifact")).Return(nil).Once()
	mockdb.On("InsertLogChunk", logChunk).Return(nil).Once()
	assert.NoError(t, AppendLogChunk(mockdb, &model.Artifact{
		State: model.APPENDING,
		Id:    10,
	}, logChunk))

	mockdb.AssertExpectations(t)
}