public void Enumeration_ShouldPassThrough()
{
// Arrange
var k1 = RandomValueGen.GetRandomString();
var k2 = RandomValueGen.GetAnother(k1);
var v1 = RandomValueGen.GetRandomString();
var v2 = RandomValueGen.GetAnother(v1);
var sut = Create <string, string>();
sut[k1] = v1;
sut[k2] = v2;
var collector = new List <KeyValuePair <string, string> >();
// Pre-assert
// Act
foreach (var kvp in sut)
{
collector.Add(kvp);
}
// Assert
Expectations.Expect(collector.Count).To.Equal(2);
Expectations.Expect(collector).To.Contain.Exactly(1).Equal.To(new KeyValuePair <string, string>(k1, v1));
Expectations.Expect(collector).To.Contain.Exactly(1).Equal.To(new KeyValuePair <string, string>(k2, v2));
}
public void GivenTwoDictionariesWhichDontIntersect_ShouldReturnValueFromEach()
{
// Arrange
var key1 = RandomValueGen.GetRandomString();
var value1 = RandomValueGen.GetRandomString();
var key2 = RandomValueGen.GetAnother(key1);
var value2 = RandomValueGen.GetAnother(value1);
var dict1 = new Dictionary <string, string>()
{
[key1] = value1
};
var dict2 = new Dictionary <string, string>()
{
[key2] = value2
};
var sut = Create(dict1, dict2);
// Pre-assert
// Act
var result1 = sut[key1];
var result2 = sut[key2];
// Assert
Expectations.Expect(result1).To.Equal(value1);
Expectations.Expect(result2).To.Equal(value2);
}
public void WhenCreatingOnDefaultSettings_ShouldCreateDefaultConfig()
{
// Arrange
var defaultIni = new INIFile.INIFile();
defaultIni.Parse(DEFAULTS);
var sut = Create();
// Pre-Assert
// Act
var rawResult = sut.GenerateFor(new TempDbMySqlServerSettings());
var resultIni = new INIFile.INIFile();
resultIni.Parse(rawResult);
// Assert
Expectations.Expect(defaultIni.Sections)
.To.Be.Equivalent.To(resultIni.Sections);
defaultIni.Sections.ForEach(section =>
{
var expectedSettings = defaultIni[section];
var resultSettings = resultIni[section];
expectedSettings.ForEach(kvp =>
{
Expectations.Expect(resultSettings.TryGetValue(kvp.Key, out var value))
.To.Be.True($"result is missing setting '{kvp.Key}'");
Expectations.Expect(value).To.Equal(kvp.Value,
$"Mismatched values for setting '{kvp.Key}'");
});
Expectations.Expect(resultSettings.Count)
.To.Equal(expectedSettings.Count);
});
}
public void ShouldPassOnTheSameLogic()
{
// Arrange
var collection = GetRandomCollection <string>(4, 7)
.Distinct()
.ToArray();
var seek = collection.Randomize().First();
// Pre-Assert
// Act
Assert.That(() =>
AssertionHelper.Expect(
collection,
AssertionHelper.Exactly(1).EqualTo(seek)
),
Throws.Nothing
);
Assert.That(() =>
Expectations.Expect(
collection,
Expectations.Exactly(1).EqualTo(seek)
),
Throws.Nothing
);
// Assert
}
public void Values_ShouldReturnAllPriorityValues()
{
// Arrange
var k1 = RandomValueGen.GetRandomString();
var k2 = RandomValueGen.GetAnother(k1);
var v1 = RandomValueGen.GetRandomString();
var v2 = RandomValueGen.GetAnother(v1);
var v3 = RandomValueGen.GetAnother <string>(new[] { v1, v2 });
var sut = Create(new Dictionary <string, string>()
{
[k1] = v1,
[k2] = v2
}, new Dictionary <string, string>()
{
[k2] = v3
});
// Pre-assert
// Act
var result = sut.Values;
// Assert
Expectations.Expect(result.Count).To.Equal(2);
Expectations.Expect(result).To.Contain.Exactly(1).Equal.To(v1);
Expectations.Expect(result).To.Contain.Exactly(1).Equal.To(v2);
}
public void Instance_ShouldAppearToBeCaseInsensitive()
{
// Arrange
var dict = new DefaultDictionary <string, object>();
// Pre-Assert
// Act
var result = dict.GetPropertyValue("Comparer");
// Assert
Expectations.Expect(result).To.Equal(StringComparer.OrdinalIgnoreCase);
}
public void ReadOnly_ShouldBeTrue()
{
// Arrange
var sut = Create(new Dictionary <string, string>());
// Pre-assert
// Act
Expectations.Expect(sut.IsReadOnly).To.Be.True();
// Assert
}
public void Matches_GivenMatchingVerb_ShouldReturnTrue(HttpMethods method, string verb)
{
//--------------- Arrange -------------------
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = method.Matches(verb);
//--------------- Assert -----------------------
Expectations.Expect(result).To.Be.True();
}
public void Comparer_WhenKeyTypeIsString_ShouldReturnLeastRestrictive2()
{
// Arrange
var sensitive = new Dictionary <string, string>(StringComparer.Ordinal);
var insensitive = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var sut = Create(insensitive, sensitive) as MergeDictionary <string, string>;
// Pre-Assert
// Act
var result = sut.Comparer;
// Assert
Expectations.Expect(result as object).To.Equal(StringComparer.OrdinalIgnoreCase);
}
public void Matches_GivenAnyVerb_WhenMethodIsAny_ShouldReturnTrue()
{
//--------------- Arrange -------------------
var method = HttpMethods.Any;
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = method.Matches(RandomValueGen.GetRandomFrom(new[] { "GET", "PUT", "POST", "Options", "PATCH" }));
//--------------- Assert -----------------------
Expectations.Expect(result).To.Be.True();
}
public void IndexFetch_WithSmartResolver_ShouldReturnExpectedValue()
{
// Arrange
var sut = new DefaultDictionary <string, string>(s => s + "moo");
var index = RandomValueGen.GetRandomString();
var expected = index + "moo";
// Pre-Assert
// Act
var result = sut[index];
// Assert
Expectations.Expect(result).To.Equal(expected);
}
public void IsReadonly_ShouldReturnFalse()
{
// Arrange
var sut = Create <int, bool>();
// Pre-assert
// Act
var result = sut.IsReadOnly;
// Assert
Expectations.Expect(result).To.Be.False();
}
public void Clear_ShouldThrow_InvalidOperationException()
{
// Arrange
var sut = Create(new Dictionary <string, string>());
// Pre-assert
// Act
Expectations.Expect(() => sut.Clear())
.To.Throw <InvalidOperationException>()
.With.Message.Containing("read-only");
// Assert
}
public void Add_GivenKeyAndValue_ShouldThrow_InvalidOperationException()
{
// Arrange
var sut = Create(new Dictionary <string, string>());
// Pre-assert
// Act
Expectations.Expect(() => sut.Add(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString()))
.To.Throw <InvalidOperationException>()
.With.Message.Containing("read-only");
// Assert
}
public void Remove_GivenKey_ShouldThrow_InvalidOperationException()
{
// Arrange
var sut = Create(new Dictionary <string, int>());
// Pre-assert
// Act
Expectations.Expect(() => sut.Remove("moo"))
.To.Throw <InvalidOperationException>()
.With.Message.Containing("read-only");
// Assert
}
public void IndexedValue_GivenNoDefaultResolverAtConstruction_WhenAskedForMissingValue_ShouldReturnDefaultOfT()
{
// Arrange
var sut = Create <string, bool>();
var key = RandomValueGen.GetRandomString();
// Pre-assert
// Act
var result = sut[key];
// Assert
Expectations.Expect(result).To.Equal(default(bool));
}
public void Add_GivenKeyAndValue_ShouldPassThrough()
{
// Arrange
var sut = Create <string, string>();
var kvp = RandomValueGen.GetRandom <KeyValuePair <string, string> >();
// Pre-assert
// Act
sut.Add(kvp.Key, kvp.Value);
// Assert
Expectations.Expect(sut[kvp.Key]).To.Equal(kvp.Value);
}
public void ShouldWorkOnNullableBooleans()
{
// Arrange
var value = false as bool?;
// Pre-Assert
// Act
Assert.That(
() => Expectations.Expect(value).To.Be.False(),
Throws.Nothing
);
// Assert
}
public void ShouldFailSimilarly()
{
// Arrange
var collection = new[] { 1, 2, 3 };
// Pre-assert
// Act
Assert.That(
() => AssertionHelper.Expect(collection, Has.Member(4)),
Throws.Exception.InstanceOf <AssertionException>());
Assert.That(
() => Expectations.Expect(collection, Has.Member(4)),
Throws.Exception.InstanceOf <AssertionException>());
// Assert
}
public void IndexedValue_GivenDefaultResolverAtConstruction_ShouldReturnThatValue()
{
// Arrange
var expected = RandomValueGen.GetRandomString();
var key = RandomValueGen.GetRandomString();
var sut = Create <string, string>(() => expected);
// Pre-assert
// Act
var result = sut[key];
// Assert
Expectations.Expect(result).To.Equal(expected);
}
public void ToBeNotTrue_WhenValueIsFalse_ShouldNotThrow()
{
// Arrange
var value = false;
// Pre-Assert
// Act
Assert.That(
() => Expectations.Expect(value).To.Be.Not.True(),
Throws.Nothing
);
// Assert
}
public void ToBeNotFalse_WhenValueIsFalse_ShouldThrow()
{
// Arrange
var value = false;
// Pre-Assert
// Act
Assert.That(
() => Expectations.Expect(value).To.Be.Not.False(),
Throws.Exception.InstanceOf <AssertionException>()
);
// Assert
}
public void Contains_WhenOneDictionaryAndItDoesNotContainAMatchingPair_ShouldReturnFalse()
{
// Arrange
var kvp = new KeyValuePair <string, string>(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString());
var inner = new Dictionary <string, string>();
var sut = Create(inner);
// Pre-assert
// Act
var result = sut.Contains(kvp);
// Assert
Expectations.Expect(result).To.Be.False();
}
public void TryGetValue_WhenKeyIsUnknown_ShouldReturnDefault()
{
// Arrange
var expected = RandomValueGen.GetRandomString();
var sut = Create <string, string>(() => expected);
// Pre-assert
// Act
var result = sut.TryGetValue(RandomValueGen.GetRandomString(), out var found);
// Assert
Expectations.Expect(result).To.Be.True();
Expectations.Expect(found).To.Equal(expected);
}
public void NotToBeTrue_WhenValueIsTrue_ShouldThrow()
{
// Arrange
var value = true;
// Pre-Assert
// Act
Assert.That(
() => Expectations.Expect(value).Not.To.Be.True(),
Throws.Exception.InstanceOf <AssertionException>()
);
// Assert
}
public void Comparer_WhenKeyTypeIsNotString_ShouldReturnFirstFound()
{
// Arrange
var c1 = new SomeComparer();
var c2 = new SomeComparer();
var d1 = new Dictionary <int, string>(c1);
var d2 = new Dictionary <int, string>(c2);
var sut = Create(d1, d2) as MergeDictionary <int, string>;
// Pre-Assert
// Act
var result = sut.Comparer;
// Assert
Expectations.Expect(result).To.Equal(c1);
}
public void Matches_WhenMethodsMatch_ShouldReturnTrue()
{
//--------------- Arrange -------------------
var left = GetRandomMethodButNotAny();
var right = left;
//--------------- Assume ----------------
//--------------- Act ----------------------
var result1 = left.Matches(right);
var result2 = right.Matches(left);
//--------------- Assert -----------------------
Expectations.Expect(result1).To.Be.True();
Expectations.Expect(result2).To.Be.True();
}
public void Count_ShouldReturnActualCount()
{
// Arrange
var sut = Create <string, bool>();
var items = RandomValueGen.GetRandomArray <KeyValuePair <string, bool> >();
items.ForEach(sut.Add);
// Pre-assert
// Act
var result = sut.Count;
// Assert
Expectations.Expect(result).To.Equal(items.Length);
}
public void ToBeTrue_WhenValueIsFalse_ShouldThrow()
{
// Arrange
var value = false;
// Pre-Assert
// Act
Assert.That(
() => Expectations.Expect(value).To.Be.True(),
Throws.Exception.InstanceOf <AssertionException>()
.With.Message.Contains($"Expected True but got {value}")
);
// Assert
}
public void Matches_IfBothAreAny_ShouldReturnTrue()
{
//--------------- Arrange -------------------
var left = HttpMethods.Any;
var right = HttpMethods.Any;
//--------------- Assume ----------------
//--------------- Act ----------------------
var result1 = left.Matches(right);
var result2 = right.Matches(left);
//--------------- Assert -----------------------
Expectations.Expect(result1).To.Be.True();
Expectations.Expect(result2).To.Be.True();
}
