public IModel Load(PropertyBag modelData)
{
try
{
var model = new Model(
modelData["name"] as string,
SemVer.Parse(modelData["version"] as string),
new ModelFactories(_valueTypeFactory, _validatorFactory, _entityFactory))
{
PropertyBag = modelData
};
model.EntitiesBySingleName = (modelData["entities"] as PropertyBag[])
.Safe()
.ToImmutableDictionary(x => x["singlename"] as string, x => MapEntityDefinition(model, x),
StringComparer.OrdinalIgnoreCase);
model.EntitiesByPluralName = model.EntitiesBySingleName.Values.ToImmutableDictionary(x => x.PluralName);
model.ModelLoaded();
return(model);
}
catch (Exception ex) when(!(ex is ModelLoadingException))
{
throw new ModelLoadingException($"There has been an error while loading the model {modelData["name"]}", ex);
}
}
public static void ParseMajorMinorPatchOnly()
{
var info = new SemVer("1.0.0");
var expected = new SemVer(1, 0, 0);
Assert.AreEqual(info, expected);
}
public async Task <KvpConfig> GetLatestConfigSetting(string name)
{
var kvpDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <ConfigKey, KvpConfig> >(KvpDictionaryName);
KvpConfig config = null;
using (var tx = this.StateManager.CreateTransaction())
{
var asyncEnumerable = await kvpDictionary.CreateEnumerableAsync(tx);
var kvps = asyncEnumerable.GetAsyncEnumerator();
SemVer greatestRelease = null;
while (await kvps.MoveNextAsync(new CancellationToken()))
{
var kvp = kvps.Current;
if (kvp.Key.Name != name)
{
continue;
}
if (greatestRelease == null)
{
greatestRelease = new SemVer(kvp.Key.Version);
}
var version = new SemVer(kvp.Key.Version);
if (greatestRelease < version)
{
greatestRelease = version;
config = (KvpConfig)kvp.Value;
}
}
}
return(config);
}
public void BailsOnInvalidSemVers(string version)
{
var ex = Assert.Throws <ArgumentException>(() => SemVer.FromString(version));
Assert.Equal("versionString", ex.ParamName);
Assert.Contains($"Malformed version part: {version}", ex.Message);
}
public void BuildTest(SemVer semVer)
{
foreach (var identifier in semVer.Build.Split('.'))
{
Assert.That(identifier, Is.Empty.Or.Match("[0-9A-Za-z-]"));
}
}
static void ParseBuildType(string input, SemVer expected)
{
SemVer info;
Assert.IsTrue(SemVer.TryGetVersionInfo(input, out info));
Assert.AreEqual(expected, info, "input: " + input);
}
private string GetLatestVersionInCache(bool ignorePrerelease)
{
FileSystemProxy.CreateDirectory(PaketCacheDir);
var zero = new SemVer();
return(FileSystemProxy.GetDirectories(PaketCacheDir)
.Select(Path.GetFileName)
.OrderByDescending(x =>
{
try
{
var version = SemVer.Create(x);
if (ignorePrerelease && version.PreRelease != null)
{
return zero;
}
else
{
return version;
}
}
catch (Exception)
{
return zero;
}
})
.FirstOrDefault() ?? "0");
}
public void TryParse_ToString_BestGuess(string str, string guess)
{
var success = SemVer.TryParse(str, out var version);
Assert.False(success);
Assert.Equal(guess, version.ToString());
}
/// <summary>
/// Selects a common protocol version that both server and client support.
/// </summary>
/// <param name="ClientVersions">List of versions that the client supports. The list is ordered by client's preference.</param>
/// <param name="SelectedCommonVersion">If the function succeeds, this is set to the selected version that both client and server support.</param>
/// <returns>true if the function succeeds, false otherwise.</returns>
public bool GetCommonSupportedVersion(IEnumerable <ByteString> ClientVersions, out SemVer SelectedCommonVersion)
{
log.Trace("()");
SelectedCommonVersion = SemVer.Invalid;
SemVer selectedVersion = SemVer.Invalid;
bool res = false;
foreach (ByteString clVersion in ClientVersions)
{
SemVer version = new SemVer(clVersion);
if (version.Equals(SemVer.V100))
{
SelectedCommonVersion = version;
selectedVersion = version;
res = true;
break;
}
}
if (res)
{
log.Trace("(-):{0},SelectedCommonVersion='{1}'", res, selectedVersion);
}
else
{
log.Trace("(-):{0}", res);
}
return(res);
}
/// <summary>
/// Creates a new identity client.
/// </summary>
/// <param name="Name">Identity name.</param>
/// <param name="Type">Identity type.</param>
/// <param name="Location">Initial GPS location.</param>
/// <param name="ImageMask">File name mask in the images folder that define which images can be randomly selected for profile image.</param>
/// <param name="ImageChance">An integer between 0 and 100 that specifies the chance of each instance to have a profile image set.</param>
public IdentityClient(string Name, string Type, GpsLocation Location, string ImageMask, int ImageChance)
{
log = new Logger("NetworkSimulator.IdentityClient", "[" + Name + "] ");
log.Trace("(Name:'{0}',Type:'{1}',Location:{2},ImageMask:'{3}',ImageChance:{4})", Name, Type, Location, ImageMask, ImageChance);
name = Name;
type = Type;
location = Location;
extraData = null;
bool hasImage = Helpers.Rng.NextDouble() < (double)ImageChance / 100;
if (hasImage)
{
imageFileName = GetImageFileByMask(ImageMask);
profileImage = imageFileName != null?File.ReadAllBytes(imageFileName) : null;
}
version = SemVer.V100;
keys = Ed25519.GenerateKeys();
identityId = Crypto.Sha256(keys.PublicKey);
messageBuilder = new PsMessageBuilder(0, new List <SemVer>()
{
SemVer.V100
}, keys);
profileInitialized = false;
hostingActive = false;
log.Trace("(-)");
}
/// <summary>
/// Starts conversation with the server the client is connected to and checks whether the server response contains expected values.
/// </summary>
/// <returns>true if the function succeeds, false otherwise.</returns>
public async Task <bool> StartConversationAsync()
{
log.Trace("()");
PsProtocolMessage requestMessage = CreateStartConversationRequest();
await SendMessageAsync(requestMessage);
PsProtocolMessage responseMessage = await ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool challengeVerifyOk = VerifyProfileServerChallengeSignature(responseMessage);
SemVer receivedVersion = new SemVer(responseMessage.Response.ConversationResponse.Start.Version);
bool versionOk = receivedVersion.Equals(new SemVer(messageBuilder.Version));
bool pubKeyLenOk = responseMessage.Response.ConversationResponse.Start.PublicKey.Length == 32;
bool challengeOk = responseMessage.Response.ConversationResponse.Start.Challenge.Length == 32;
profileServerKey = responseMessage.Response.ConversationResponse.Start.PublicKey.ToByteArray();
challenge = responseMessage.Response.ConversationResponse.Start.Challenge.ToByteArray();
bool res = idOk && statusOk && challengeVerifyOk && versionOk && pubKeyLenOk && challengeOk;
log.Trace("(-):{0}", res);
return(res);
}
public void IsEqualTo()
{
var ver = new SemVer("3.3.0");
Assert.IsFalse(ver == "3.2.1");
Assert.IsTrue(ver == "3.3.0");
}
public void CanParseValidSemVers(
string version,
int expectedMajor,
int expectedMinor,
int expectedPatch,
string expectedPreReleaseBuildInfo,
string expectedBuildMeta,
bool isValid
)
{
if (!isValid)
{
var ex = Record.Exception(() => SemVer.FromString(version));
Assert.IsAssignableFrom <ArgumentException>(ex);
return;
}
var semver = SemVer.FromString(version);
Assert.Equal(expectedMajor, semver.Major);
Assert.Equal(expectedMinor, semver.Minor);
Assert.Equal(expectedPatch, semver.Patch);
Assert.Equal(expectedPreReleaseBuildInfo, semver.PreRelease);
Assert.Equal(expectedBuildMeta, semver.BuildMeta);
if (!string.IsNullOrWhiteSpace(semver.PreRelease))
{
Assert.True(semver.IsPreRelease);
}
}
public void IsLessThan()
{
var ver = new SemVer("3.2.1");
Assert.IsFalse(ver < "3.0.0");
Assert.IsTrue(ver < "3.3.0");
}
public void IsGreaterThan()
{
var ver = new SemVer("3.3.0");
Assert.IsTrue(ver > "3.2.1");
Assert.IsFalse(ver > "3.3.0");
}
public void BailsOnInvalidSemVers(string version)
{
var ex = Assert.Throws <ArgumentException>(() => SemVer.FromString(version));
Assert.Equal(ex.ParamName, "versionString");
Assert.Equal(ex.Message, $"Malformed version part: {version}{Environment.NewLine}Parameter name: versionString");
}
private string GetLatestVersionInCache(bool ignorePrerelease)
{
DirectoryProxy.CreateDirectory(_paketCacheDir);
var zero = new SemVer();
return DirectoryProxy.GetDirectories(_paketCacheDir)
.Select(Path.GetFileName)
.OrderByDescending(x =>
{
try
{
var version = SemVer.Create(x);
if (ignorePrerelease && version.PreRelease != null)
return zero;
else
return version;
}
catch (Exception)
{
return zero;
}
})
.FirstOrDefault() ?? "0";
}
public void Compare_And_CompareTo()
{
for (var i = 0; i < Versions.Length - 1; i++)
{
var a = Versions[i];
Assert.Equal(a, a);
if (a != null)
{
Assert.Equal(a, SemVer.Parse(a.ToString()));
}
Assert.False(a < null);
Assert.False(a > null);
Assert.False(a <= null);
Assert.False(a >= null);
for (var j = i + 1; j < Versions.Length; j++)
{
var b = Versions[j];
Assert.NotEqual(a, b);
Assert.True(SemVer.Compare(a, b) < 0, $"{ a } is not smaller than { b }");
if (a != null)
{
Assert.True(a.CompareTo(b) < 0);
}
}
}
Assert.Equal(Versions, Versions.OrderBy(x => x, Comparer <SemVer> .Default));
}
public void IsLessThanOrEqualTo()
{
var ver = new SemVer("3.3.0");
Assert.IsFalse(ver <= "3.2.1");
Assert.IsTrue(ver <= "3.3.0");
Assert.IsTrue(ver <= "3.4.0");
}
public void CompareTo(int majorA, int minorA, int patchA, ReleaseFlag releaseFlagA, int majorB, int minorB, int patchB, ReleaseFlag releaseFlagB, int expected)
{
SemVer semVerA = new SemVer(majorA, minorA, patchA, releaseFlagA);
SemVer semVerB = new SemVer(majorB, minorB, patchB, releaseFlagB);
Assert.AreEqual(expected, semVerA.CompareTo(semVerB));
}
public void Should_Return_Matching_String(int major, int minor, int patch, string label, string version)
{
var semver = new SemVer {
Major = major, Minor = minor, Patch = patch, Label = label
};
Assert.Equal(version, semver.ToString());
}
public void CanBumpAndSerializeStringVersion(string version, VersionBump bump, string expectedVersion)
{
var semver = SemVer.FromString(version);
semver.Bump(bump);
Assert.Equal(semver.ToVersionString(), expectedVersion);
}
public ModelMock(IEnumerable <IEntityDefinition> entityDefinitions = null, IModelFactories factories = null)
{
Name = "TestModel";
Version = new SemVer(1, 0, 0);
EntitiesBySingleName = entityDefinitions.Safe().ToImmutableDictionary(x => x.SingleName);
EntitiesByPluralName = entityDefinitions.Safe().ToImmutableDictionary(x => x.PluralName);
Factories = factories ?? new ModelFactoriesMock();
}
[InlineData("4.1.3.6.7.8.9", 4, 1, 3)] // too many version numbers
public void CanParseValidSemVers(string version, int expectedMajor, int expectedMinor, int expectedPatch)
{
var semver = SemVer.FromString(version);
Assert.Equal(expectedMajor, semver.Major);
Assert.Equal(expectedMinor, semver.Minor);
Assert.Equal(expectedPatch, semver.Patch);
}
public void GetSuitVersionTest21HighestNoVersion()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "2.2.0-alpha"
};
Assert.Throws <InvalidOperationException>(() => semVer.GetSuitVersion(true, VersionSelectMethod.Highest));
}
public void CanParseSemverString(string input, int major, int minor, int patch, string suffix)
{
var result = SemVer.Parse(input);
Assert.Equal(result.Major, major);
Assert.Equal(result.Minor, minor);
Assert.Equal(result.Patch, patch);
Assert.Equal(result.Suffix, suffix);
}
public void GetSuitVersionTest33LowestNoVersion()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "[,1.0.0)"
};
Assert.Throws <InvalidOperationException>(() => semVer.GetSuitVersion(true, VersionSelectMethod.Lowest));
}
public void GetSuitVersionTest31LowestLessPreRelease()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "[,2.2.0-alpha)"
};
Assert.That(semVer.GetSuitVersion(false, VersionSelectMethod.Lowest), Is.EqualTo("1.0.0-alpha"));
}
public void GetSuitVersionTest29LowestLessEqual()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "[,2.2.0-alpha]"
};
Assert.That(semVer.GetSuitVersion(true, VersionSelectMethod.Lowest), Is.EqualTo("1.0.0"));
}
public void GetSuitVersionTest28LowestGraterPreRelease()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "(1.0.0-beta,]"
};
Assert.That(semVer.GetSuitVersion(false, VersionSelectMethod.Lowest), Is.EqualTo("1.0.0-beta.2"));
}
public void GetSuitVersionTest24LowestGraterEqual()
{
var semVer = new SemVer()
{
ExistVersion = setVersion.ToList(), AllowedVersion = "2.0.0"
};
Assert.That(semVer.GetSuitVersion(true, VersionSelectMethod.Lowest), Is.EqualTo("2.0.0"));
}
public bool IsOlderThan(SemVer semVer)
{
if (semVer.Major > Major)
return true;
if (semVer.Major == Major && semVer.Minor > Minor)
return true;
if (semVer.Major == Major && semVer.Minor == Minor && semVer.Patch > Patch)
return true;
return false;
}
