public void PullRequiringMerge(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, IObjectRepositoryContainerFactory containerFactory, Signature signature, string message)
{
// Arrange
sut = container.AddRepository(sut, signature, message);
var tempPath = RepositoryFixture.GetAvailableFolderPath();
var clientContainer = containerFactory.Create <ObjectRepository>(tempPath);
clientContainer.Clone(container.Repositories.Single().RepositoryDescription.Path);
// Arrange - Update source repository
var change = sut.With(sut.Applications[0].Pages[0], p => p.Description, "foo");
sut = container.Commit(change.Repository, signature, message);
// Arrange - Update client repository
var clientChange = sut.With(sut.Applications[0].Pages[0], p => p.Name, "bar");
clientContainer.Commit(clientChange.Repository, signature, message);
// Act
var pullResult = clientContainer.Pull(clientContainer.Repositories.Single().Id);
pullResult.Apply(signature);
// Assert
Assert.That(pullResult.RequiresMergeCommit, Is.True);
Assert.That(clientContainer.Repositories.Single().Applications[0].Pages[0].Description, Is.EqualTo("foo"));
}
public void LinkFieldSerialization(IServiceProvider serviceProvider, IObjectRepositoryContainer container, string name, string path)
{
// Arrange
var sut = CreateJsonRepositorySerializer(serviceProvider, new ModelObjectSerializationContext(container));
var link = new LazyLink <Page>(container, new ObjectPath(UniqueId.CreateNew(), path));
var linkField = new Field.Builder(serviceProvider)
{
Id = UniqueId.CreateNew(),
Name = name,
Content = FieldContent.NewLink(new FieldLinkContent(link))
}.ToImmutable();
// Act
var json = Serialize(sut, linkField);
using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
{
var deserialized = (Field)sut.Deserialize(stream, _ => throw new NotSupportedException());
var deserializedLazyLink = deserialized.Content.MatchOrDefault(matchLink: c => c.Target);
// Assert
Assert.That(deserialized.Id, Is.EqualTo(linkField.Id));
Assert.That(deserialized.Name, Is.EqualTo(name));
Assert.That(deserializedLazyLink.Path.Path, Is.EqualTo(path));
}
}
public void MergeFileDeletionChange(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message, ComputeTreeChangesFactory computeTreeChangesFactory)
{
// master: A---C---D
// \ /
// newBranch: B---'
// Arrange
var a = container.AddRepository(sut, signature, message); // A
// Act
a = container.Checkout(a.Id, "newBranch", createNewBranch: true);
var page = a.Applications[0].Pages[0];
var updateName = a.With(c => c.Remove(page, p => p.Fields, page.Fields[1]));
container.Commit(updateName, signature, message); // B
a = container.Checkout(a.Id, "master");
var updateDescription = a.With(a.Applications[0].Pages[0], p => p.Description, "modified description");
var commitC = container.Commit(updateDescription.Repository, signature, message); // C
var mergeCommit = container.Merge(sut.Id, "newBranch").Apply(signature); // D
// Assert
var changes = computeTreeChangesFactory(container, container[sut.Id].RepositoryDescription)
.Compare(commitC.CommitId, mergeCommit)
.SkipIndexChanges();
Assert.That(changes, Has.Count.EqualTo(1));
Assert.That(changes[0].Status, Is.EqualTo(ChangeKind.Deleted));
Assert.That(changes[0].Old.Id, Is.EqualTo(page.Fields[1].Id));
}
public void MergeFileAdditionChange(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, IServiceProvider serviceProvider, Signature signature, string message, ComputeTreeChangesFactory computeTreeChangesFactory)
{
// master: A---C---D
// \ /
// newBranch: B---'
// Arrange
sut = container.AddRepository(sut, signature, message); // A
// Act
sut = container.Checkout(sut.Id, "newBranch", createNewBranch: true);
var updateName = sut.With(c => c.Add(sut.Applications[0].Pages[0], p => p.Fields, new Field(serviceProvider, UniqueId.CreateNew(), "new field", FieldContent.Default)));
container.Commit(updateName.Repository, signature, message); // B
var a = container.Checkout(sut.Id, "master");
var updateDescription = a.With(a.Applications[0].Pages[0], p => p.Description, "modified description");
var commitC = container.Commit(updateDescription.Repository, signature, message); // C
var mergeCommit = container.Merge(sut.Id, "newBranch").Apply(signature); // D
// Assert
var changes = computeTreeChangesFactory(container, container[sut.Id].RepositoryDescription)
.Compare(commitC.CommitId, mergeCommit)
.SkipIndexChanges();
Assert.That(changes, Has.Count.EqualTo(1));
Assert.That(changes[0].Status, Is.EqualTo(ChangeKind.Added));
Assert.That(changes[0].New.Name, Is.EqualTo("new field"));
}
public void MergeTwoDifferentPropertiesChanged(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message, ComputeTreeChangesFactory computeTreeChangesFactory)
{
// master: A---C---D
// \ /
// newBranch: B---'
// Arrange
sut = container.AddRepository(sut, signature, message); // A
// Act
sut = container.Checkout(sut.Id, "newBranch", createNewBranch: true);
var updateName = sut.With(sut.Applications[0].Pages[0], p => p.Name, "modified name");
container.Commit(updateName.Repository, signature, message); // B
var a = container.Checkout(sut.Id, "master");
var updateDescription = a.With(a.Applications[0].Pages[0], p => p.Description, "modified description");
var commitC = container.Commit(updateDescription.Repository, signature, message); // C
var mergeCommit = container.Merge(sut.Id, "newBranch").Apply(signature); // D
// Assert
var changes = computeTreeChangesFactory(container, container[sut.Id].RepositoryDescription)
.Compare(commitC.CommitId, mergeCommit)
.SkipIndexChanges();
Assert.That(changes, Has.Count.EqualTo(1));
Assert.That(changes[0].Status, Is.EqualTo(ChangeKind.Modified));
Assert.That(changes[0].Old.Name, Is.EqualTo(sut.Applications[0].Pages[0].Name));
Assert.That(changes[0].New.Name, Is.EqualTo(updateName.Name));
}
public void ObjectDeletionIsAlsoDeletingBlobs(BlobRepository repository, IObjectRepositoryContainer <BlobRepository> container, Signature signature, string message)
{
// Arrange
var a = container.AddRepository(repository, signature, message);
// Act
var b = container.Commit(
repository.With(c => c.Remove(repository, r => r.Cars, repository.Cars[0])),
signature,
message);
// Assert
b.Execute(r =>
{
var changes = r.Diff.Compare <TreeChanges>(
r.Lookup <Commit>(a.CommitId).Tree,
r.Lookup <Commit>(b.CommitId).Tree);
Assert.That(
changes.Deleted.Select(c => c.Path),
Is.EquivalentTo(new[]
{
$"Cars/{a.Cars[0].Id}/blob{FileSystemStorage.BlobExtension}",
$"Cars/{a.Cars[0].Id}/{FileSystemStorage.DataFile}"
}));
});
}
public void MergeSamePropertyConflict(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message, ComputeTreeChangesFactory computeTreeChangesFactory)
{
// master: A---C---D
// \ /
// newBranch: B---'
// Arrange
var a = container.AddRepository(sut, signature, message); // A
// Act
a = container.Checkout(sut.Id, "newBranch", createNewBranch: true);
var updateName = a.With(a.Applications[0].Pages[0], p => p.Name, "modified name");
container.Commit(updateName.Repository, signature, message); // B
a = container.Checkout(sut.Id, "master");
var updateNameOther = a.With(a.Applications[0].Pages[0], p => p.Name, "yet again modified name");
var commitC = container.Commit(updateNameOther.Repository, signature, message); // C
var merge = container.Merge(sut.Id, "newBranch");
var chunk = merge.ModifiedProperties.Single();
chunk.Resolve("merged name");
var mergeCommit = merge.Apply(signature); // D
// Assert
var changes = computeTreeChangesFactory(container, container[sut.Id].RepositoryDescription)
.Compare(commitC.CommitId, mergeCommit)
.SkipIndexChanges();
Assert.That(changes, Has.Count.EqualTo(1));
Assert.That(changes[0].Status, Is.EqualTo(ChangeKind.Modified));
Assert.That(changes[0].Old.Name, Is.EqualTo("yet again modified name"));
Assert.That(changes[0].New.Name, Is.EqualTo("merged name"));
}
public void CloneRepository(IObjectRepositoryContainer <ObjectRepository> container)
{
// Act
var loaded = container.Clone(RepositoryFixture.SmallRepositoryPath);
// Assert
Assert.That(loaded.Applications, Has.Count.EqualTo(2));
}
internal MigrationScaffolder(IObjectRepositoryContainer container, RepositoryDescription repositoryDescription,
IRepositoryProvider repositoryProvider, ObjectRepositorySerializerFactory repositorySerializerFactory)
{
_repositoryProvider = repositoryProvider ?? throw new ArgumentNullException(nameof(repositoryProvider));
_container = container ?? throw new ArgumentNullException(nameof(container));
_repositoryDescription = repositoryDescription ?? throw new ArgumentNullException(nameof(repositoryDescription));
_repositorySerializerFactory = repositorySerializerFactory ?? throw new ArgumentNullException(nameof(repositorySerializerFactory));
}
private IEnumerable <IModelObject> LoadEntryChildren(IObjectRepositoryContainer container, ObjectId commitId, string childPath, Tree subTree) =>
from c in subTree
where c.TargetType == TreeEntryTargetType.Tree
let childTree = (Tree)c.Target
let data = childTree[FileSystemStorage.DataFile]
where data != null
select LoadEntry(container, commitId, data, $"{childPath}/{c.Name}",
relativePath => (subTree[relativePath]?.Target as Blob)?.GetContentText() ?? string.Empty);
public void LazyLinkCloneCopiesObjectPath(IObjectRepositoryContainer <ObjectRepository> container, Page page)
{
// Act
var sut = (LazyLink <Page>) new LazyLink <Page>(container, page).Clone();
// Assert
Assert.That(sut.IsLinkCreated, Is.False);
Assert.That(sut.Path, Is.EqualTo(page.Path));
}
public void CherryPickDetectsConflicts(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
var cherryPick = CreateConflictingCherryPick(sut, container, signature, message);
// Assert
Assert.That(cherryPick.Status, Is.EqualTo(CherryPickStatus.Conflicts));
Assert.That(cherryPick.ModifiedProperties, Has.Count.EqualTo(1));
Assert.That(cherryPick.ModifiedProperties, Has.Exactly(1).Matches <ObjectRepositoryPropertyChange>(c => c.IsInConflict));
}
public void RebaseDetectsConflicts(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
var rebase = CreateConflictingRebase(sut, container, signature, message);
// Assert
Assert.That(rebase.Status, Is.EqualTo(RebaseStatus.Conflicts));
Assert.That(rebase.ModifiedProperties, Has.Count.EqualTo(3));
Assert.That(rebase.ModifiedProperties, Has.Exactly(1).Matches <ObjectRepositoryPropertyChange>(c => c.IsInConflict));
}
public void CommitPageNameUpdate(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
sut = container.AddRepository(sut, signature, message);
var modifiedPage = sut.With(sut.Applications[0].Pages[0], p => p.Name, "modified");
var updated = container.Commit(modifiedPage.Repository, signature, message);
var retrievedPage = updated.Flatten().OfType <Page>().FirstOrDefault(p => p.Name == "modified");
// Assert
Assert.That(retrievedPage.Name, Is.EqualTo("modified"));
}
public void LoadLargeRepository(IObjectRepositoryContainer <ObjectRepository> container, IObjectRepositoryLoader loader)
{
// Arrange
var stopwatch = Stopwatch.StartNew();
// Act
loader.LoadFrom(container, RepositoryFixture.BenchmarkRepositoryDescription);
// Assert
// Child loading is lazy so root load time should be really short
Assert.That(stopwatch.Elapsed, Is.LessThan(TimeSpan.FromMilliseconds(300)));
}
public void BlobSerializedAsNestedFile(BlobRepository sut, IObjectRepositoryContainer <BlobRepository> container, Signature signature, string message)
{
// Arrange
sut = container.AddRepository(sut, signature, message);
// Assert
sut.Execute(r =>
{
var blob = (Blob)r.Head[$"blob{FileSystemStorage.BlobExtension}"].Target;
Assert.AreEqual(sut.Blob.Value, blob.GetContentText());
});
}
public void LazyLinkCloneDuplicatesFactoryWithoutInvokingIt(IObjectRepositoryContainer <ObjectRepository> container)
{
// Act
var exception = new Exception();
var sut = (LazyLink <Page>) new LazyLink <Page>(container, () => throw exception).Clone();
// Assert
Assert.That(sut.IsLinkCreated, Is.False);
var thrown = Assert.Throws <Exception>(() => sut.Link.ToString());
Assert.That(thrown, Is.SameAs(exception));
}
public void PushNewRemote(ObjectRepository sample, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
var(tempPath, repository) = PushNewRemoteImpl(sample, container, signature, message);
// Assert
using (var repo = new Repository(tempPath))
{
var lastCommit = repo.Branches["master"].Tip;
Assert.That(lastCommit.Id, Is.EqualTo(repository.CommitId));
}
}
public void CherryPickConflictsCanResolvedAndContinued(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
var cherryPick = CreateConflictingCherryPick(sut, container, signature, message);
cherryPick.ModifiedProperties.Single(c => c.IsInConflict).Resolve("resolved");
cherryPick.Commit();
// Assert
Assert.That(cherryPick.Status, Is.EqualTo(CherryPickStatus.CherryPicked));
Assert.That(container.Repositories.Single().Applications[0].Pages[0].Name, Is.EqualTo("resolved"));
}
public ComputeTreeChanges(IObjectRepositoryContainer container, RepositoryDescription repositoryDescription,
IModelDataAccessorProvider modelDataProvider, IObjectRepositoryLoader objectRepositoryLoader,
IRepositoryProvider repositoryProvider, ILogger <ComputeTreeChanges> logger)
{
_container = container ?? throw new ArgumentNullException(nameof(container));
_repositoryDescription = repositoryDescription ?? throw new ArgumentNullException(nameof(repositoryDescription));
_modelDataProvider = modelDataProvider ?? throw new ArgumentNullException(nameof(modelDataProvider));
_objectRepositoryLoader = objectRepositoryLoader ?? throw new ArgumentNullException(nameof(objectRepositoryLoader));
_repositoryProvider = repositoryProvider ?? throw new ArgumentNullException(nameof(repositoryProvider));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public void MergeBlobConflictsCanResolvedAndContinued(BlobRepository sut, IObjectRepositoryContainer <BlobRepository> container, Signature signature, string message)
{
// Act
CreateConflictingChange(sut, container, signature, message);
var merge = container.Merge(sut.Id, "master");
merge.ModifiedProperties.Single(c => c.IsInConflict).Resolve(new StringBlob("y\nb\nd"));
merge.Apply(signature);
// Assert
Assert.That(container.Repositories.Single().Blob, Is.EqualTo(new StringBlob("y\nb\nd")));
}
public void RebaseConflictsCanResolvedAndContinued(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Act
var rebase = CreateConflictingRebase(sut, container, signature, message);
rebase.ModifiedProperties.Single(c => c.IsInConflict).Resolve("resolved");
rebase.Continue();
// Assert
Assert.That(rebase.Status, Is.EqualTo(RebaseStatus.Complete));
Assert.That(rebase.TotalStepCount, Is.EqualTo(1));
Assert.That(container.Repositories.Single().Applications[0].Pages[0].Name, Is.EqualTo("resolved"));
}
/// <inheritdoc/>
public IList <IModelObject> Grep(IObjectRepositoryContainer container, string content, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
return(container.Repositories.SelectMany(r => Grep(r, content, comparison)).ToList());
}
static void CreateConflictingChange(BlobRepository sut, IObjectRepositoryContainer <BlobRepository> container, Signature signature, string message)
{
// master: A---B
// \ (B & C change same value)
// newBranch: C -> A---B---C
var a = container.AddRepository(sut, signature, message); // A
var updateName = a.With(a, r => r.Blob, new StringBlob("x\nb\nc"));
container.Commit(updateName.Repository, signature, message); // B
container.Checkout(a.Id, "newBranch", createNewBranch: true, "HEAD~1");
var updates = a.With(a, r => r.Blob, new StringBlob("z\nb\nd"));
container.Commit(updates, signature, message);
}
public void ThrowIfMissingDependency(IObjectRepositoryContainer <ObjectRepository> container, ObjectRepository repository, Signature signature, string message)
{
// Arrange
var wrongDependency = new RepositoryDependency(UniqueId.CreateNew(), "foo", new System.Version(1, 0));
repository = repository.With(repository, r => r.Dependencies, repository.Dependencies.Add(wrongDependency));
container.AddRepository(repository, signature, message);
// Act
var result = container.Validate();
// Assert
Assert.That(result.ToString(), Does.Contain("could not be found"));
}
/// <inheritdoc />
public IObjectRepository LoadFrom(IObjectRepositoryContainer container, RepositoryDescription repositoryDescription, ObjectId commitId = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (repositoryDescription == null)
{
throw new ArgumentNullException(nameof(repositoryDescription));
}
return(_repositoryProvider.Execute(repositoryDescription, repository =>
LoadFrom(container, repositoryDescription, repository, commitId)));
}
public void RebaseBlobConflictsCanResolvedAndContinued(BlobRepository sut, IObjectRepositoryContainer <BlobRepository> container, Signature signature, string message)
{
// Act
CreateConflictingChange(sut, container, signature, message);
var rebase = container.Rebase(sut.Id, "master");
rebase.ModifiedProperties.Single(c => c.IsInConflict).Resolve(new StringBlob("y\nb\nd"));
rebase.Continue();
// Assert
Assert.That(rebase.Status, Is.EqualTo(RebaseStatus.Complete));
Assert.That(rebase.TotalStepCount, Is.EqualTo(1));
Assert.That(container.Repositories.Single().Blob, Is.EqualTo(new StringBlob("y\nb\nd")));
}
public void ResolveLinkReferers(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Arrange
sut = container.AddRepository(sut, signature, message);
var linkField = sut.Flatten().OfType <Field>().First(
f => f.Content.MatchOrDefault(matchLink: l => true));
var target = linkField.Content.MatchOrDefault(matchLink: c => c.Target).Link;
// Act
var referrers = sut.GetReferrers(target);
// Assert
Assert.That(referrers, Does.Contain(linkField));
}
private ILazyChildren LoadEntryChildren(IObjectRepositoryContainer container, ObjectId commitId, string path, ChildPropertyInfo childProperty) =>
LazyChildrenHelper.Create(childProperty, (parent, repository) =>
{
var childPath = string.IsNullOrEmpty(path) ? childProperty.FolderName : $"{path}/{childProperty.FolderName}";
var commit = repository.Lookup <Commit>(commitId);
var entry = commit[childPath];
if (entry == null)
{
return(Enumerable.Empty <IModelObject>());
}
var subTree = (Tree)entry.Target;
return(subTree.Any() ?
LoadEntryChildren(container, commitId, childPath, subTree) :
Enumerable.Empty <IModelObject>());
});
public void ResolveLinkReferersUsingIndex(ObjectRepository sut, IObjectRepositoryContainer <ObjectRepository> container, Signature signature, string message)
{
// Arrange
sut = container.AddRepository(sut, signature, message);
var linkField = sut.Flatten().OfType <Field>().First(
f => f.Content.MatchOrDefault(matchLink: l => true));
var target = linkField.Content.MatchOrDefault(matchLink: c => c.Target).Link;
// Act
var index = sut.Indexes.Single(i => i is LinkFieldReferrerIndex);
var referrers = index[target.Path.FullPath];
// Assert
Assert.That(referrers, Does.Contain(linkField));
}
