diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Build.NetFramework/Microsoft.OData.Edm.Tests.csproj b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Build.NetFramework/Microsoft.OData.Edm.Tests.csproj index 18312faa32..d7c7f88055 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Build.NetFramework/Microsoft.OData.Edm.Tests.csproj +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Build.NetFramework/Microsoft.OData.Edm.Tests.csproj @@ -40,10 +40,6 @@ ..\..\..\..\tools\StrongNamePublicKeys\testkey.snk - - False - ..\..\..\..\sln\packages\FluentAssertions.2.0.0.1\lib\net40\FluentAssertions.dll - diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlReaderTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlReaderTests.cs index 34a8887181..77ca92f9ad 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlReaderTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlReaderTests.cs @@ -9,7 +9,6 @@ using System.Linq; using System.Xml; using System.Xml.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Validation; @@ -192,15 +191,15 @@ var csdl var setA = model.FindDeclaredNavigationSource("Root"); var target = setA.NavigationPropertyBindings.First().Target; Assert.True(target is IEdmContainedEntitySet); - target.Name.Should().Be("SetB"); + Assert.Equal("SetB", target.Name); var targetSegments = target.Path.PathSegments.ToList(); - targetSegments.Count().Should().Be(2); - targetSegments[0].Should().Be("Root"); - targetSegments[1].Should().Be("SetB"); + Assert.Equal(2, targetSegments.Count()); + Assert.Equal("Root", targetSegments[0]); + Assert.Equal("SetB", targetSegments[1]); var pathSegments = setA.NavigationPropertyBindings.First().Path.PathSegments.ToList(); - pathSegments.Count().Should().Be(2); - pathSegments[0].Should().Be("EntityA"); - pathSegments[1].Should().Be("EntityAToB"); + Assert.Equal(2, pathSegments.Count()); + Assert.Equal("EntityA", pathSegments[0]); + Assert.Equal("EntityAToB", pathSegments[1]); } [Fact] @@ -238,25 +237,26 @@ var csdl IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(csdl).CreateReader(), out model, out errors).Should().BeTrue(); - errors.Count().Should().Be(0); + var result = CsdlReader.TryParse(XElement.Parse(csdl).CreateReader(), out model, out errors); + Assert.True(result); + Assert.Empty(errors); model.Validate(out errors); - errors.Count().Should().Be(0); + Assert.Empty(errors); var educationSingleton = model.FindDeclaredNavigationSource("education"); var navPropBinding = educationSingleton.NavigationPropertyBindings.First(); var target = navPropBinding.Target; - target.Should().NotBeNull(); + Assert.NotNull(target); Assert.True(target is IEdmContainedEntitySet); - target.Name.Should().Be("users"); + Assert.Equal("users", target.Name); var targetSegments = target.Path.PathSegments.ToList(); - targetSegments.Count().Should().Be(2); - targetSegments[0].Should().Be("education"); - targetSegments[1].Should().Be("users"); + Assert.Equal(2, targetSegments.Count()); + Assert.Equal("education", targetSegments[0]); + Assert.Equal("users", targetSegments[1]); var pathSegments = navPropBinding.Path.PathSegments.ToList(); - pathSegments.Count().Should().Be(2); - pathSegments[0].Should().Be("classes"); - pathSegments[1].Should().Be("members"); + Assert.Equal(2, pathSegments.Count()); + Assert.Equal("classes", pathSegments[0]); + Assert.Equal("members", pathSegments[1]); } [Fact] @@ -537,8 +537,9 @@ public void ParsingInvalidXmlWithMultipleEntityContainersShouldThrow() "; Action parseAction = () => CsdlReader.Parse(XElement.Parse(EdmxwithMultipleEntityContainers).CreateReader()); - parseAction.ShouldThrow().Where(e => e.Message.Contains( - Strings.CsdlParser_MetadataDocumentCannotHaveMoreThanOneEntityContainer)).And.Errors.Should().HaveCount(1); + var exception = Assert.Throws(parseAction); + Assert.Contains(Strings.CsdlParser_MetadataDocumentCannotHaveMoreThanOneEntityContainer, exception.Message); + Assert.Equal(1, exception.Errors.Count); } [Fact] @@ -786,14 +787,17 @@ private string GetStringAnnotation(IEdmModel model, IEdmVocabularyAnnotatable ta private void RunValidTest(Func parse) { var result = parse(this.validReader); - result.Should().NotBeNull(); - result.EntityContainer.FullName().Should().Be("Test.Container"); + Assert.NotNull(result); + Assert.Equal("Test.Container", result.EntityContainer.FullName()); } private void RunInvalidTest(Func parse) { Action parseAction = () => parse(this.invalidReader); - parseAction.ShouldThrow().WithMessage(ErrorStrings.EdmParseException_ErrorsEncounteredInEdmx(ErrorMessage)).And.Errors.Should().OnlyContain(e => e.ToString() == ErrorMessage); + + EdmParseException exception = Assert.Throws(parseAction); + Assert.Equal(ErrorStrings.EdmParseException_ErrorsEncounteredInEdmx(ErrorMessage), exception.Message); + Assert.Single(exception.Errors, e => e.ToString() == ErrorMessage); } private static IEdmModel GetEdmModel(string types = "", string properties = "") diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs index 78b3628007..2a93b25bd0 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs @@ -9,12 +9,10 @@ using System.IO; using System.Linq; using System.Xml; - using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Validation; using Microsoft.OData.Edm.Vocabularies; using Microsoft.OData.Edm.Vocabularies.V1; - using Xunit; namespace Microsoft.OData.Edm.Tests.Csdl diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmEnumValueParserTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmEnumValueParserTests.cs index ea4ef0335d..7d947d71f7 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmEnumValueParserTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmEnumValueParserTests.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Xunit; @@ -24,8 +23,8 @@ public void TryParseEnumMemberOfOneValueShouldBeTrue() string enumPath = " Ns.Color/Blue "; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue(); - parsedMember.Single().Should().Be(blue); + Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); + Assert.Equal(blue, parsedMember.Single()); } [Fact] @@ -38,10 +37,10 @@ public void TryParseEnumMemberOfInvalidStringsShouldBeFalse() string enumPath = " "; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse(); + Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); enumPath = " / "; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse(); + Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); } [Fact] @@ -51,10 +50,10 @@ public void TryParseEnumMemberOfMultipleInvalidTypeShouldBeTrue() string enumPath = "Ns.Color/Blue Ns.Color/Red"; List types = new List { complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue(); - parsedMember.Count().Should().Be(2); - parsedMember.First().Name.Should().Be("Blue"); - parsedMember.ElementAt(1).Name.Should().Be("Red"); + Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); + Assert.Equal(2, parsedMember.Count()); + Assert.Equal("Blue", parsedMember.First().Name); + Assert.Equal("Red", parsedMember.ElementAt(1).Name); } [Fact] @@ -67,7 +66,7 @@ public void TryParseEnumMemberOfInvalidPathShouldBeFalse() string enumPath = "Ns.Color//Blue"; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse(); + Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); } [Fact] @@ -80,9 +79,9 @@ public void TryParseEnumMemberOfInvalidEnumTypeShouldBeTrue() string enumPath = "Ns.Colors/Blue"; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue(); - parsedMember.Count().Should().Be(1); - parsedMember.First().Name.Should().Be("Blue"); + Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); + var mem = Assert.Single(parsedMember); + Assert.Equal("Blue", mem.Name); } [Fact] @@ -95,7 +94,7 @@ public void TryParseEnumMemberOfInvalidEnumMemberShouldBeFalse() string enumPath = "Ns.Color/Green"; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse(); + Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); } [Fact] @@ -108,10 +107,10 @@ public void TryParseEnumMemberWithFlagsOfTwoValuesShouldBeTrue() string enumPath = " Ns.Permission/Read Ns.Permission/Write "; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue(); - parsedMember.Count().Should().Be(2); - parsedMember.First().Should().Be(read); - parsedMember.Last().Should().Be(write); + Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); + Assert.Equal(2, parsedMember.Count()); + Assert.Equal(read, parsedMember.First()); + Assert.Equal(write, parsedMember.Last()); } [Fact] @@ -124,7 +123,7 @@ public void TryParseEnumMemberWithoutFlagsOfTwoValueShouldBeFalse() string enumPath = "Ns.Permission/Read Ns.Permission/Write"; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse(); + Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); } [Fact] @@ -138,9 +137,11 @@ public void TryParseEnumMemberWithFlagsOfMultiValueShouldBeTrue() string enumPath = "Ns.Permission/Read Ns.Permission/Write Ns.Permission/ReadWrite"; List types = new List { enumType, complexType }; IEnumerable parsedMember; - EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue(); - parsedMember.Count().Should().Be(3); - parsedMember.Should().Contain(read).And.Contain(write).And.Contain(readwrite); + Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember)); + Assert.Equal(3, parsedMember.Count()); + Assert.Contains(read, parsedMember); + Assert.Contains(write, parsedMember); + Assert.Contains(readwrite, parsedMember); } private static IEdmModel BuildModelFromTypes(IEnumerable types) diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueParserTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueParserTests.cs index 58d8fb5508..98ff64361c 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueParserTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueParserTests.cs @@ -5,9 +5,7 @@ //--------------------------------------------------------------------- using System; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Csdl @@ -19,21 +17,21 @@ public class EdmValueParserTests public void ParseDateNullShouldThrowFormatException() { Date? result; - EdmValueParser.TryParseDate(null, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseDate(null, out result)); } [Fact] public void ParseDateWithEmptyStringShouldThrowFormatException() { Date? result; - EdmValueParser.TryParseDate(string.Empty, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseDate(string.Empty, out result)); } [Fact] public void ParseDateWithSpaceShouldThrowFormatException() { Date? result; - EdmValueParser.TryParseDate(" ", out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseDate(" ", out result)); } [Fact] @@ -64,7 +62,7 @@ public void ParseDateWithInvalidParameterShouldThrowFormatException() foreach (var invalidDate in invalidDates) { Date? result; - EdmValueParser.TryParseDate(invalidDate, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseDate(invalidDate, out result)); } } @@ -72,8 +70,8 @@ public void ParseDateWithInvalidParameterShouldThrowFormatException() public void TryParseDateWithValidParameterShouldParseCorrectly() { Date? result; - EdmValueParser.TryParseDate("2012-07-28", out result).Should().BeTrue(); - result.Should().Be(new Date(2012, 07, 28)); + Assert.True(EdmValueParser.TryParseDate("2012-07-28", out result)); + Assert.Equal(new Date(2012, 07, 28), result); } #endregion @@ -85,24 +83,24 @@ public void TryParseDateWithValidParameterShouldParseCorrectly() public void TryParseDateTimeOffsetThatProvidesEverythingShouldParseCorrectly() { DateTimeOffset? result; - EdmValueParser.TryParseDateTimeOffset("2012-07-28T13:22:16.123-07:15", out result).Should().BeTrue(); - result.Should().Be(new DateTimeOffset(2012, 7, 28, 13, 22, 16, 123, new TimeSpan(-7, -15, 0))); + Assert.True(EdmValueParser.TryParseDateTimeOffset("2012-07-28T13:22:16.123-07:15", out result)); + Assert.Equal(new DateTimeOffset(2012, 7, 28, 13, 22, 16, 123, new TimeSpan(-7, -15, 0)), result); } [Fact] public void TryParseDateTimeOffsetWithInvalidFormatShouldReturnFalse() { DateTimeOffset? result; - EdmValueParser.TryParseDateTimeOffset("0001+01+01T00:00:00.000+00:01", out result).Should().BeFalse(); - result.Should().BeNull(); + Assert.False(EdmValueParser.TryParseDateTimeOffset("0001+01+01T00:00:00.000+00:01", out result)); + Assert.Null(result); } [Fact] public void TryParseDateTimeOffsetThatOverFlowsShouldReturnFalse() { DateTimeOffset? result; - EdmValueParser.TryParseDateTimeOffset("0001-01-01T00:00:00.000+00:01", out result).Should().BeFalse(); - result.Should().BeNull(); + Assert.False(EdmValueParser.TryParseDateTimeOffset("0001-01-01T00:00:00.000+00:01", out result)); + Assert.Null(result); } #endregion @@ -116,49 +114,49 @@ public void TryParseDateTimeOffsetThatOverFlowsShouldReturnFalse() public void ParseDurationWith1DecimalPlaceShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.9S"); - result.Should().Be(new TimeSpan(9000000)); + Assert.Equal(new TimeSpan(9000000), result); } [Fact] public void ParseDurationWith2DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.09S"); - result.Should().Be(new TimeSpan(900000)); + Assert.Equal(new TimeSpan(900000), result); } [Fact] public void ParseDurationWith3DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.009S"); - result.Should().Be(new TimeSpan(90000)); + Assert.Equal(new TimeSpan(90000), result); } [Fact] public void ParseDurationWith4DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.0009S"); - result.Should().Be(new TimeSpan(9000)); + Assert.Equal(new TimeSpan(9000), result); } [Fact] public void ParseDurationWith5DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.00009S"); - result.Should().Be(new TimeSpan(900)); + Assert.Equal(new TimeSpan(900), result); } [Fact] public void ParseDurationWith6DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.000009S"); - result.Should().Be(new TimeSpan(90)); + Assert.Equal(new TimeSpan(90), result); } [Fact] public void ParseDurationWith7DecimalPlacesShouldNotLosePrecision() { TimeSpan result = EdmValueParser.ParseDuration("PT0.0000009S"); - result.Should().Be(new TimeSpan(9)); + Assert.Equal(new TimeSpan(9), result); } [Fact] @@ -166,49 +164,49 @@ public void ParseDurationWithMoreThan7DecimalPlacesShouldNotLosePrecisionUpTo7() { // 12 is the max precison supported in OData protocol, but Clr TimeSpan only supports up to 7 decimal places TimeSpan result = EdmValueParser.ParseDuration("PT0.123456789012S"); - result.Should().Be(new TimeSpan(1234567)); + Assert.Equal(new TimeSpan(1234567), result); } [Fact] public void ParseDurationWithTrailingSpaces() { TimeSpan result = EdmValueParser.ParseDuration("PT1S "); - result.Should().Be(new TimeSpan(0, 0, 1)); + Assert.Equal(new TimeSpan(0, 0, 1), result); } [Fact] public void ParseDurationWithLeadingSpaces() { TimeSpan result = EdmValueParser.ParseDuration(" PT1S"); - result.Should().Be(new TimeSpan(0, 0, 1)); + Assert.Equal(new TimeSpan(0, 0, 1), result); } [Fact] public void ParseDurationWithMaxValueShouldReturnCorrectTimeSpan() { TimeSpan result = EdmValueParser.ParseDuration("P10675199DT2H48M5.4775807S"); - result.ShouldBeEquivalentTo(TimeSpan.MaxValue); + Assert.Equal(TimeSpan.MaxValue, result); } [Fact] public void ParseDurationWithMaxValueMinusOneShouldReturnCorrectTimeSpan() { TimeSpan result = EdmValueParser.ParseDuration("P10675199DT2H48M5.4775806S"); - result.ShouldBeEquivalentTo(TimeSpan.MaxValue - new TimeSpan(1)); + Assert.Equal(TimeSpan.MaxValue - new TimeSpan(1), result); } [Fact] public void ParseDurationWithMinValueShouldReturnCorrectTimeSpan() { TimeSpan result = EdmValueParser.ParseDuration("-P10675199DT2H48M5.4775808S"); - result.ShouldBeEquivalentTo(TimeSpan.MinValue); + Assert.Equal(TimeSpan.MinValue, result); } [Fact] public void ParseDurationWithMinValuePlusOneShouldReturnCorrectTimeSpan() { TimeSpan result = EdmValueParser.ParseDuration("-P10675199DT2H48M5.4775807S"); - result.ShouldBeEquivalentTo(TimeSpan.MinValue + new TimeSpan(1)); + Assert.Equal(TimeSpan.MinValue + new TimeSpan(1), result); } #endregion @@ -220,7 +218,7 @@ public void ParseDurationWithNullShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(null); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } [Fact] @@ -231,7 +229,7 @@ public void ParseDurationWithEmptyStringShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(string.Empty); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } [Fact] @@ -242,7 +240,7 @@ public void ParseDurationWithWhiteSpaceShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(" "); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } [Fact] @@ -275,7 +273,7 @@ public void ParseDurationWithYearPartShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(invalidDuration); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } } @@ -309,7 +307,7 @@ public void ParseDurationWithMonthPartShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(invalidDuration); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } } @@ -343,7 +341,7 @@ public void ParseDurationWithYearAndMonthPartsShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration(invalidDuration); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } } @@ -355,7 +353,7 @@ public void ParseDurationWithNonDurationValueShouldThrowFormatException() TimeSpan result = EdmValueParser.ParseDuration("+P1D"); }; - parseDuration.ShouldThrow(); + Assert.Throws(parseDuration); } [Fact] @@ -366,31 +364,31 @@ public void ParseDurationThatOverflowsShouldThrowOverflowException() TimeSpan result = EdmValueParser.ParseDuration("P10675199DT2H48M5.4775808S"); }; - tryParseDuration.ShouldThrow(); + Assert.Throws(tryParseDuration); } [Fact] public void TryParseDurationWithInvalidDurationShouldBeFalse() { TimeSpan? result; - EdmValueParser.TryParseDuration(null, out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.False(EdmValueParser.TryParseDuration(null, out result)); + Assert.Null(result); } [Fact] public void TryParseDurationWithValidDurationShouldBeTrue() { TimeSpan? result; - EdmValueParser.TryParseDuration(string.Empty, out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.False(EdmValueParser.TryParseDuration(string.Empty, out result)); + Assert.Null(result); } [Fact] public void TryParseDurationThatOverflowsShouldBeFalse() { TimeSpan? result; - EdmValueParser.TryParseDuration("P10675199DT2H48M5.4775808S", out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.False(EdmValueParser.TryParseDuration("P10675199DT2H48M5.4775808S", out result)); + Assert.Null(result); } #endregion @@ -399,40 +397,40 @@ public void TryParseDurationThatOverflowsShouldBeFalse() public void TryParseIntThatOverFlowsShouldBeFalse() { int? result; - EdmValueParser.TryParseInt("-2147483648", out result).Should().BeTrue(); - result.Should().Be(int.MinValue); - EdmValueParser.TryParseInt("-2147483649", out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.True(EdmValueParser.TryParseInt("-2147483648", out result)); + Assert.Equal(int.MinValue, result); + Assert.False(EdmValueParser.TryParseInt("-2147483649", out result)); + Assert.Null(result); } [Fact] public void TryParseLongThatOverFlowsShouldBeFalse() { long? result; - EdmValueParser.TryParseLong("9223372036854775807", out result).Should().BeTrue(); - result.Should().Be(long.MaxValue); - EdmValueParser.TryParseLong("9223372036854775808", out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.True(EdmValueParser.TryParseLong("9223372036854775807", out result)); + Assert.Equal(long.MaxValue, result); + Assert.False(EdmValueParser.TryParseLong("9223372036854775808", out result)); + Assert.Null(result); } [Fact] public void TryParseDecimalThatOverFlowsShouldBeFalse() { decimal? result; - EdmValueParser.TryParseDecimal("-79228162514264337593543950335", out result).Should().BeTrue(); - result.Should().Be(decimal.MinValue); - EdmValueParser.TryParseDecimal("-79228162514264337593543950336", out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.True(EdmValueParser.TryParseDecimal("-79228162514264337593543950335", out result)); + Assert.Equal(decimal.MinValue, result); + Assert.False(EdmValueParser.TryParseDecimal("-79228162514264337593543950336", out result)); + Assert.Null(result); } [Fact] public void TryParseFloatThatOverFlowsShouldBeFalse() { double? result; - EdmValueParser.TryParseFloat("1.7976931348623157E+308", out result).Should().BeTrue(); - result.Should().Be(double.MaxValue); - EdmValueParser.TryParseFloat("1.7976931348623157E+309", out result).Should().BeFalse(); - result.Should().NotHaveValue(); + Assert.True(EdmValueParser.TryParseFloat("1.7976931348623157E+308", out result)); + Assert.Equal(double.MaxValue, result); + Assert.False(EdmValueParser.TryParseFloat("1.7976931348623157E+309", out result)); + Assert.Null(result); } #endregion Decimal @@ -441,21 +439,21 @@ public void TryParseFloatThatOverFlowsShouldBeFalse() public void ParseTimeOfDayNullShouldThrowFormatException() { TimeOfDay? result; - EdmValueParser.TryParseTimeOfDay(null, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseTimeOfDay(null, out result)); } [Fact] public void ParseTimeOfDayWithEmptyStringShouldThrowFormatException() { TimeOfDay? result; - EdmValueParser.TryParseTimeOfDay(string.Empty, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseTimeOfDay(string.Empty, out result)); } [Fact] public void ParseTimeOfDayWithSpaceShouldThrowFormatException() { TimeOfDay? result; - EdmValueParser.TryParseTimeOfDay(" ", out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseTimeOfDay(" ", out result)); } [Fact] @@ -472,7 +470,7 @@ public void ParseTimeOfDayWithInvalidParameterShouldThrowFormatException() foreach (var invalidTimeOfDay in invalidTimeOfDays) { TimeOfDay? result; - EdmValueParser.TryParseTimeOfDay(invalidTimeOfDay, out result).Should().BeFalse(); + Assert.False(EdmValueParser.TryParseTimeOfDay(invalidTimeOfDay, out result)); } } @@ -480,8 +478,8 @@ public void ParseTimeOfDayWithInvalidParameterShouldThrowFormatException() public void TryParseTimeOfDayWithValidParameterShouldParseCorrectly() { TimeOfDay? result; - EdmValueParser.TryParseTimeOfDay("1:12:5.009000", out result).Should().BeTrue(); - result.Should().Be(new TimeOfDay(1, 12, 5, 9)); + Assert.True(EdmValueParser.TryParseTimeOfDay("1:12:5.009000", out result)); + Assert.Equal(new TimeOfDay(1, 12, 5, 9), result); } #endregion } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueWriterTests.cs index c41068ebb0..d15c3af2d5 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueWriterTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/EdmValueWriterTests.cs @@ -5,9 +5,7 @@ //--------------------------------------------------------------------- using System; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Csdl @@ -31,9 +29,9 @@ public void DateAsXmlWithValidShouldRoundtripWhenParsed() { Date? parsedDate; var result = EdmValueWriter.DateAsXml(date); - EdmValueParser.TryParseDate(result, out parsedDate).Should().BeTrue(); + Assert.True(EdmValueParser.TryParseDate(result, out parsedDate)); - parsedDate.Should().Be(date); + Assert.Equal(date, parsedDate); } } #endregion @@ -64,7 +62,7 @@ public void DurationAsXmlWithValidDurationShouldNotContainYearOrMonth() foreach (var timeSpan in this.validTimeSpans) { var result = EdmValueWriter.DurationAsXml(timeSpan); - EdmValueParser.DayTimeDurationValidator.IsMatch(result).Should().BeTrue(); + Assert.True(EdmValueParser.DayTimeDurationValidator.IsMatch(result)); } } @@ -75,9 +73,9 @@ public void DurationAsXmlWithValidShouldRoundtripWhenParsed() { TimeSpan? parsedTimeSpan; var result = EdmValueWriter.DurationAsXml(timeSpan); - EdmValueParser.TryParseDuration(result, out parsedTimeSpan).Should().BeTrue(); + Assert.True(EdmValueParser.TryParseDuration(result, out parsedTimeSpan)); - parsedTimeSpan.Should().Be(timeSpan); + Assert.Equal(timeSpan, parsedTimeSpan); } } #endregion @@ -100,9 +98,9 @@ public void TimeOfDayyAsXmlWithValidShouldRoundtripWhenParsed() { TimeOfDay? parsedTime; var result = EdmValueWriter.TimeOfDayAsXml(time); - EdmValueParser.TryParseTimeOfDay(result, out parsedTime).Should().BeTrue(); + Assert.True(EdmValueParser.TryParseTimeOfDay(result, out parsedTime)); - parsedTime.Should().Be(time); + Assert.Equal(time, parsedTime); } } #endregion diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/Ast/CsdlTypeDefinitionTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/Ast/CsdlTypeDefinitionTests.cs index 59596fc5d7..4c1b8523cf 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/Ast/CsdlTypeDefinitionTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/Ast/CsdlTypeDefinitionTests.cs @@ -4,7 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.Parsing.Ast; using Xunit; @@ -19,9 +18,9 @@ public void TestCsdlTypeDefinitionConstructor() var loc = new CsdlLocation(17, 4); var type = new CsdlTypeDefinition("Length", "Edm.Int32", loc); - type.Location.Should().Be(loc); - type.Name.Should().Be("Length"); - type.UnderlyingTypeName.Should().Be("Edm.Int32"); + Assert.Equal(loc, type.Location); + Assert.Equal("Length", type.Name); + Assert.Equal("Edm.Int32", type.UnderlyingTypeName); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntityContainerTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntityContainerTests.cs index bae9a57a6c..1fe2bb5525 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntityContainerTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntityContainerTests.cs @@ -5,8 +5,6 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; @@ -30,24 +28,23 @@ public void EnsureFunctionImportFunctionPropertyIsUnresolvedFunction() var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); - + var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); - imports.Should().HaveCount(1); - var csdlFunctionImport = (IEdmFunctionImport)imports[0]; - csdlFunctionImport.Name.Should().Be("GetStuff"); - csdlFunctionImport.Operation.GetType().Should().Be(typeof(UnresolvedFunction)); - var errors = csdlFunctionImport.Operation.As().Errors.ToList(); - errors.Should().HaveCount(1); - errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff")); - csdlFunctionImport.Container.Name.Should().Be("Container"); - csdlFunctionImport.Location().Should().Be(testLocation); - csdlFunctionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.FunctionImport); - csdlFunctionImport.EntitySet.Should().BeNull(); - csdlFunctionImport.IncludeInServiceDocument.Should().BeTrue(); - csdlFunctionImport.Function.IsComposable.Should().BeFalse(); + var csdlFunctionImport = Assert.Single(imports) as IEdmFunctionImport; + Assert.Equal("GetStuff", csdlFunctionImport.Name); + Assert.IsType(csdlFunctionImport.Operation); + var errors = (csdlFunctionImport.Operation as BadElement).Errors.ToList(); + var error = Assert.Single(errors); + Assert.Equal(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff"), error.ErrorMessage); + Assert.Equal("Container", csdlFunctionImport.Container.Name); + Assert.Equal(testLocation, csdlFunctionImport.Location()); + Assert.Equal(EdmContainerElementKind.FunctionImport, csdlFunctionImport.ContainerElementKind); + Assert.Null(csdlFunctionImport.EntitySet); + Assert.True(csdlFunctionImport.IncludeInServiceDocument); + Assert.False(csdlFunctionImport.Function.IsComposable); } [Fact] @@ -62,16 +59,16 @@ public void EnsureActionImportActionPropertyIsUnresolvedAction() CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); - imports.Should().HaveCount(1); - imports[0].Name.Should().Be("Action"); - imports[0].Operation.GetType().Should().Be(typeof(UnresolvedAction)); - var errors = imports[0].Operation.As().Errors.ToList(); - errors.Should().HaveCount(1); - errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.Action")); - imports[0].Container.Name.Should().Be("Container"); - imports[0].Location().Should().Be(testLocation); - imports[0].ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); - imports[0].EntitySet.Should().BeNull(); + Assert.Single(imports); + Assert.Equal("Action", imports[0].Name); + Assert.IsType(imports[0].Operation); + var errors = (imports[0].Operation as BadElement).Errors.ToList(); + var error = Assert.Single(errors); + Assert.Equal(Strings.Bad_UnresolvedOperation("FQ.NS.Action"), error.ErrorMessage); + Assert.Equal("Container", imports[0].Container.Name); + Assert.Equal(testLocation, imports[0].Location()); + Assert.Equal(EdmContainerElementKind.ActionImport, imports[0].ContainerElementKind); + Assert.Null(imports[0].EntitySet); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntitySetTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntitySetTests.cs index 5b28bbd0e3..a5fd33e297 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntitySetTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsEntitySetTests.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; @@ -51,9 +50,9 @@ public CsdlSemanticsEntitySetTests() this.semanticContainer = new CsdlSemanticsEntityContainer(this.semanticSchema, this.csdlContainer); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; - this.semanticEntityType.Should().NotBeNull(); + Assert.NotNull(this.semanticEntityType); this.navigationProperty = this.semanticEntityType.FindProperty("Navigation") as CsdlSemanticsNavigationProperty; - this.navigationProperty.Should().NotBeNull(); + Assert.NotNull(this.navigationProperty); } [Fact] @@ -62,9 +61,9 @@ public void FindNavigationTargetShouldReturnUnresolvedEntitySetIfEntitySetIsNotF var nonExistentBinding = new CsdlNavigationPropertyBinding("Navigation", "NonExistent", new CsdlLocation(1, 1)); var testSubject = new CsdlSemanticsEntitySet(this.semanticContainer, new CsdlEntitySet("Fake", "FQ.NS.EntityType", new[] { nonExistentBinding }, null)); var result = testSubject.FindNavigationTarget(this.navigationProperty); - result.Should().BeAssignableTo(); - result.As().Name.Should().Be("NonExistent"); - result.Errors().Should().Contain(e => e.ErrorLocation == nonExistentBinding.Location && e.ErrorCode == EdmErrorCode.BadUnresolvedEntitySet); + var entitySet = Assert.IsType(result); + Assert.Equal("NonExistent", entitySet.Name); + Assert.Contains(result.Errors(), e => e.ErrorLocation == nonExistentBinding.Location && e.ErrorCode == EdmErrorCode.BadUnresolvedEntitySet); } [Fact] @@ -79,9 +78,9 @@ public void FindNavigationTargetShouldReturnSetIfItIsFound() { var testSubject = new CsdlSemanticsEntitySet(this.semanticContainer, this.csdlEntitySet); var result = testSubject.FindNavigationTarget(this.navigationProperty); - result.Should().BeAssignableTo(); - result.As().Name.Should().Be("EntitySet"); - result.Errors().Should().BeEmpty(); + var entitySet = Assert.IsType(result); + Assert.Equal("EntitySet", entitySet.Name); + Assert.Empty(result.Errors()); } [Fact] @@ -90,13 +89,13 @@ public void NavigationTargetsShouldStillContainMappingsThatAreCompletelyWrong() var location = new CsdlLocation(1, 1); var result = this.ParseSingleBinding("NonExistentPath", "NonExistentSet", location); - result.Target.Should().BeAssignableTo(); - result.Target.As().Name.Should().Be("NonExistentSet"); - result.Target.Errors().Should().Contain(e => e.ErrorLocation == location && e.ErrorCode == EdmErrorCode.BadUnresolvedEntitySet); + var entitySet = Assert.IsType(result.Target); + Assert.Equal("NonExistentSet", entitySet.Name); + Assert.Contains(result.Target.Errors(), e => e.ErrorLocation == location && e.ErrorCode == EdmErrorCode.BadUnresolvedEntitySet); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.As().Name.Should().Be("NonExistentPath"); - result.NavigationProperty.Errors().Should().Contain(e => e.ErrorLocation == location && e.ErrorCode == EdmErrorCode.BadUnresolvedNavigationPropertyPath); + var npPath = Assert.IsType(result.NavigationProperty); + Assert.Equal("NonExistentPath", npPath.Name); + Assert.Contains(result.NavigationProperty.Errors(), e => e.ErrorLocation == location && e.ErrorCode == EdmErrorCode.BadUnresolvedNavigationPropertyPath); } [Fact] @@ -104,12 +103,12 @@ public void NavigationTargetsShouldHandleNavigationsOnDerivedTypes() { var result = this.ParseSingleBinding("FQ.NS.DerivedEntityType/DerivedNavigation", "EntitySet"); - result.Target.Should().BeAssignableTo(); - result.Target.Name.Should().Be("EntitySet"); + Assert.IsType(result.Target); + Assert.Equal("EntitySet", result.Target.Name); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be("DerivedNavigation"); - result.NavigationProperty.DeclaringEntityType().FullName().Should().Be("FQ.NS.DerivedEntityType"); + Assert.IsType(result.NavigationProperty); + Assert.Equal("DerivedNavigation", result.NavigationProperty.Name); + Assert.Equal("FQ.NS.DerivedEntityType", result.NavigationProperty.DeclaringEntityType().FullName()); } [Fact] @@ -117,9 +116,9 @@ public void NavigationTargetsShouldHandleFullyQualifiedTypeWithPropertyEvenIfNot { var result = this.ParseSingleBinding("FQ.NS.EntityType/Navigation", "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be("Navigation"); - result.NavigationProperty.DeclaringEntityType().FullName().Should().Be("FQ.NS.EntityType"); + Assert.IsType(result.NavigationProperty); + Assert.Equal("Navigation", result.NavigationProperty.Name); + Assert.Equal("FQ.NS.EntityType", result.NavigationProperty.DeclaringEntityType().FullName()); } [Fact] @@ -127,9 +126,9 @@ public void NavigationTargetsShouldHandleAccessToBaseTypePropertyOnDerivedType() { var result = this.ParseSingleBinding("FQ.NS.DerivedEntityType/Navigation", "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be("Navigation"); - result.NavigationProperty.DeclaringEntityType().FullName().Should().Be("FQ.NS.EntityType"); + Assert.IsType(result.NavigationProperty); + Assert.Equal("Navigation", result.NavigationProperty.Name); + Assert.Equal("FQ.NS.EntityType", result.NavigationProperty.DeclaringEntityType().FullName()); } [Fact] @@ -138,8 +137,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfMultipleSlashesAreFound() const string pathWithMultipleSlashes = "FQ.NS.DerivedEntityType/DerivedNavigation/"; var result = this.ParseSingleBinding(pathWithMultipleSlashes, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be(pathWithMultipleSlashes); + Assert.IsType(result.NavigationProperty); + Assert.Equal(pathWithMultipleSlashes, result.NavigationProperty.Name); } [Fact] @@ -148,8 +147,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfSlashIsFirstCharacter() const string pathStartingWithSlash = "/DerivedNavigation"; var result = this.ParseSingleBinding(pathStartingWithSlash, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be(pathStartingWithSlash); + Assert.IsType(result.NavigationProperty); + Assert.Equal(pathStartingWithSlash, result.NavigationProperty.Name); } [Fact] @@ -158,8 +157,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfSlashIsLastCharacter() const string pathEndingWithSlash = "FQ.NS.DerivedEntityType/"; var result = this.ParseSingleBinding(pathEndingWithSlash, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be(pathEndingWithSlash); + Assert.IsType(result.NavigationProperty); + Assert.Equal(pathEndingWithSlash, result.NavigationProperty.Name); } [Fact] @@ -168,8 +167,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfTypeIsNotDerivedFromStarti const string pathWithNonExistentType = "FQ.NS.UnrelatedEntityType/DerivedNavigation"; var result = this.ParseSingleBinding(pathWithNonExistentType, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be(pathWithNonExistentType); + Assert.IsType(result.NavigationProperty); + Assert.Equal(pathWithNonExistentType, result.NavigationProperty.Name); } [Fact] @@ -178,8 +177,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfTypeIsNotFound() const string pathWithNonExistentType = "NonExistentType/DerivedNavigation"; var result = this.ParseSingleBinding(pathWithNonExistentType, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().Be(pathWithNonExistentType); + Assert.IsType(result.NavigationProperty); + Assert.Equal(pathWithNonExistentType, result.NavigationProperty.Name); } [Fact] @@ -187,8 +186,8 @@ public void NavigationTargetShouldHaveUnresolvedPathIfPathIsEmpty() { var result = this.ParseSingleBinding(string.Empty, "EntitySet"); - result.NavigationProperty.Should().BeAssignableTo(); - result.NavigationProperty.Name.Should().BeEmpty(); + Assert.IsType(result.NavigationProperty); + Assert.Empty(result.NavigationProperty.Name); } private IEdmNavigationPropertyBinding ParseSingleBinding(string path, string target, CsdlLocation location = null) @@ -196,8 +195,7 @@ private IEdmNavigationPropertyBinding ParseSingleBinding(string path, string tar var binding = new CsdlNavigationPropertyBinding(path, target, location); var testSubject = new CsdlSemanticsEntitySet(this.semanticContainer, new CsdlEntitySet("Fake", "FQ.NS.EntityType", new[] { binding }, null)); - testSubject.NavigationPropertyBindings.Should().HaveCount(1); - var result = testSubject.NavigationPropertyBindings.Single(); + var result = Assert.Single(testSubject.NavigationPropertyBindings); return result; } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsNavigationPropertyTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsNavigationPropertyTests.cs index 84de2f55c3..7e212eef5a 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsNavigationPropertyTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsNavigationPropertyTests.cs @@ -5,8 +5,6 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; @@ -48,193 +46,203 @@ public CsdlSemanticsNavigationPropertyTests() var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty()); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; - this.semanticEntityType.Should().NotBeNull(); + Assert.NotNull(this.semanticEntityType); this.semanticCollectionNavigation = this.semanticEntityType.FindProperty("Collection") as CsdlSemanticsNavigationProperty; this.semanticReferenceNavigation = this.semanticEntityType.FindProperty("Reference") as CsdlSemanticsNavigationProperty; this.semanticNavigationWithoutPartner = this.semanticEntityType.FindProperty("WithoutPartner") as CsdlSemanticsNavigationProperty; - this.semanticCollectionNavigation.Should().NotBeNull(); - this.semanticReferenceNavigation.Should().NotBeNull(); - this.semanticNavigationWithoutPartner.Should().NotBeNull(); + Assert.NotNull(this.semanticCollectionNavigation); + Assert.NotNull(this.semanticReferenceNavigation); + Assert.NotNull(this.semanticNavigationWithoutPartner); } [Fact] public void NavigationPartnerShouldWorkIfExplicitlySpecified() { - this.collectionProperty.PartnerPath.Path.Should().Be("Reference"); // ensure that the test configuration is unchanged. - this.semanticCollectionNavigation.Partner.Should().BeSameAs(this.semanticReferenceNavigation); + Assert.Equal("Reference", this.collectionProperty.PartnerPath.Path); // ensure that the test configuration is unchanged. + Assert.Same(this.semanticReferenceNavigation, this.semanticCollectionNavigation.Partner); } [Fact] public void NavigationPartnerShouldWorkIfAnotherPropertyOnTheTargetTypeHasThisPropertyExplicitlySpecified() { - this.referenceProperty.PartnerPath.Should().BeNull(); // ensure that the test configuration is unchanged. - this.semanticReferenceNavigation.Partner.Should().BeSameAs(this.semanticCollectionNavigation); + Assert.Null(this.referenceProperty.PartnerPath); // ensure that the test configuration is unchanged. + Assert.Same(this.semanticCollectionNavigation, this.semanticReferenceNavigation.Partner); } [Fact] public void NavigationPartnerShouldBeNullIfItDoesNotHaveOne() { - this.semanticNavigationWithoutPartner.Partner.Should().BeNull(); + Assert.Null(this.semanticNavigationWithoutPartner.Partner); } [Fact] public void NavigationPartnerShouldHaveErrorIfItCannotBeResolved() { var testSubject = this.ParseAndGetPartner("Nonexistent", "FQ.NS.EntityType"); - testSubject.Should().BeAssignableTo(); - testSubject.As().Errors - .Should().HaveCount(1) - .And.Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedNavigationPropertyPath && e.ErrorMessage.Contains("Nonexistent")); + var unNpPath = Assert.IsType(testSubject); + var error = Assert.Single(unNpPath.Errors); + Assert.Equal(EdmErrorCode.BadUnresolvedNavigationPropertyPath, error.ErrorCode); + Assert.Contains("Nonexistent", error.ErrorMessage); } [Fact] public void NavigationPartnerShouldHaveErrorIfTheTargetTypeCannotBeResolved() { var testSubject = this.ParseAndGetPartner("Navigation", "Fake.Fake"); - testSubject.Should().BeAssignableTo(); - testSubject.As().Errors - .Should().HaveCount(1) - .And.Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedNavigationPropertyPath && e.ErrorMessage.Contains("Navigation")); - testSubject.DeclaringEntityType().Should().BeAssignableTo(); - testSubject.DeclaringEntityType().FullName().Should().Be("Fake.Fake"); - testSubject.Type.Definition.Should().BeAssignableTo(); + var unNpPath = Assert.IsType(testSubject); + var error = Assert.Single(unNpPath.Errors); + Assert.Equal(EdmErrorCode.BadUnresolvedNavigationPropertyPath, error.ErrorCode); + Assert.Contains("Navigation", error.ErrorMessage); + Assert.IsType(testSubject.DeclaringEntityType()); + Assert.Equal("Fake.Fake", testSubject.DeclaringEntityType().FullName()); + Assert.IsType(testSubject.Type.Definition); } [Fact] public void PropertyShouldNotBePrincipalIfItHasAConstraint() { // assert test setup matches expectation - this.collectionProperty.ReferentialConstraints.Should().NotBeEmpty(); - this.referenceProperty.ReferentialConstraints.Should().BeEmpty(); - this.semanticCollectionNavigation.IsPrincipal().Should().BeFalse(); + Assert.NotEmpty(this.collectionProperty.ReferentialConstraints); + Assert.Empty(this.referenceProperty.ReferentialConstraints); + Assert.False(this.semanticCollectionNavigation.IsPrincipal()); } [Fact] public void PropertyShouldNotBePrincipalIfPartnerIsNull() { - this.semanticNavigationWithoutPartner.IsPrincipal().Should().BeFalse(); + Assert.False(this.semanticNavigationWithoutPartner.IsPrincipal()); } [Fact] public void PropertyShouldBePrincipalIfItsPartnerHasAConstraint() { // assert test setup matches expectation - this.collectionProperty.ReferentialConstraints.Should().NotBeEmpty(); - this.referenceProperty.ReferentialConstraints.Should().BeEmpty(); - this.semanticReferenceNavigation.IsPrincipal().Should().BeTrue(); + Assert.NotEmpty(this.collectionProperty.ReferentialConstraints); + Assert.Empty(this.referenceProperty.ReferentialConstraints); + Assert.True(this.semanticReferenceNavigation.IsPrincipal()); } [Fact] public void ConstraintShouldBeNullIfNotPresentInCsdl() { - this.semanticReferenceNavigation.ReferentialConstraint.Should().BeNull(); + Assert.Null(this.semanticReferenceNavigation.ReferentialConstraint); } [Fact] public void ConstraintShouldBePopulatedIfPresentInCsdl() { - this.semanticCollectionNavigation.ReferentialConstraint.Should().NotBeNull(); - this.semanticCollectionNavigation.ReferentialConstraint.PropertyPairs - .Should().HaveCount(1) - .And.Contain(p => p.DependentProperty.Name == "FK" && !(p.DependentProperty is BadProperty) - && p.PrincipalProperty.Name == "ID" && !(p.PrincipalProperty is BadProperty)); + Assert.NotNull(this.semanticCollectionNavigation.ReferentialConstraint); + var property = Assert.Single(this.semanticCollectionNavigation.ReferentialConstraint.PropertyPairs); + Assert.Equal("FK", property.DependentProperty.Name); + Assert.False(property.DependentProperty is BadProperty); + Assert.Equal("ID", property.PrincipalProperty.Name); + Assert.False(property.PrincipalProperty is BadProperty); } [Fact] public void ConstraintShouldHaveUnresolvedPrincipalPropertyIfPropertyDoesNotExist() { var result = this.ParseSingleConstraint("FK", "NonExistent"); - result.ReferentialConstraint.PropertyPairs.Should().HaveCount(1).And.Contain(r => r.PrincipalProperty is UnresolvedProperty); + var property = Assert.Single(result.ReferentialConstraint.PropertyPairs); + Assert.IsType(property.PrincipalProperty); } [Fact] public void ConstraintShouldHaveUnresolvedPrincipalPropertyIfPropertyIsEmpty() { var result = this.ParseSingleConstraint("FK", string.Empty); - result.ReferentialConstraint.PropertyPairs.Should().HaveCount(1).And.Contain(r => r.PrincipalProperty is UnresolvedProperty); + var property = Assert.Single(result.ReferentialConstraint.PropertyPairs); + Assert.IsType(property.PrincipalProperty); } [Fact] public void ConstraintShouldHaveUnresolvedDependentPropertyIfPropertyDoesNotExist() { var result = this.ParseSingleConstraint("NonExistent", "ID"); - result.DependentProperties().Should().HaveCount(1).And.Contain(p => p is UnresolvedProperty && p.Name == "NonExistent"); + var property = Assert.Single(result.DependentProperties()); + Assert.IsType(property); + Assert.Equal("NonExistent", property.Name); } [Fact] public void ConstraintShouldHaveUnresolvedDependentPropertyIfPropertyIsEmpty() { var result = this.ParseSingleConstraint(string.Empty, "ID"); - result.DependentProperties().Should().HaveCount(1).And.Contain(p => p is UnresolvedProperty); + var property = Assert.Single(result.DependentProperties()); + Assert.IsType(property); } [Fact] public void NavigationPropertyShouldNotAllowPrimitiveType() { var testSubject = this.ParseNavigation("Edm.Int32", null); - testSubject.Errors().Should().HaveCount(1).And.Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedEntityType); + var error = Assert.Single(testSubject.Errors()); + Assert.Equal(EdmErrorCode.BadUnresolvedEntityType, error.ErrorCode); } [Fact] public void NavigationPropertyShouldNotAllowNullabilityOnCollectionType() { var testSubject = this.ParseNavigation("Collection(FQ.NS.EntityType)", false); - testSubject.Errors().Should().HaveCount(1).And.Contain(e => e.ErrorCode == EdmErrorCode.NavigationPropertyWithCollectionTypeCannotHaveNullableAttribute); + var error = Assert.Single(testSubject.Errors()); + Assert.Equal(EdmErrorCode.NavigationPropertyWithCollectionTypeCannotHaveNullableAttribute, error.ErrorCode); } [Fact] public void NavigationPropertyShouldRespectNullableAttributeWhenFalse() { var testSubject = this.ParseNavigation("FQ.NS.EntityType", false); - testSubject.Type.IsNullable.Should().BeFalse(); + Assert.False(testSubject.Type.IsNullable); } [Fact] public void NavigationPropertyShouldRespectNullableAttributeWhenTrue() { var testSubject = this.ParseNavigation("FQ.NS.EntityType", true); - testSubject.Type.IsNullable.Should().BeTrue(); + Assert.True(testSubject.Type.IsNullable); } [Fact] public void NavigationPropertyNullabilityShouldBeDefaultWhenUnspecified() { var testSubject = this.ParseNavigation("FQ.NS.EntityType", null); - testSubject.Type.IsNullable.Should().Be(CsdlConstants.Default_Nullable); + Assert.Equal(CsdlConstants.Default_Nullable, testSubject.Type.IsNullable); } [Fact] public void NavigationPropertyTypeParsingShouldWorkForEntityType() { var testSubject = this.ParseNavigation("FQ.NS.EntityType", null); - testSubject.Type.Definition.Should().BeSameAs(this.semanticEntityType); + Assert.Same(this.semanticEntityType, testSubject.Type.Definition); } [Fact] public void NavigationPropertyTypeParsingShouldWorkForEntityCollectionType() { var testSubject = this.ParseNavigation("Collection(FQ.NS.EntityType)", null); - testSubject.Type.IsCollection().Should().BeTrue(); - testSubject.Type.AsCollection().ElementType().Definition.Should().BeSameAs(this.semanticEntityType); + Assert.True(testSubject.Type.IsCollection()); + Assert.Same(this.semanticEntityType, testSubject.Type.AsCollection().ElementType().Definition); } [Fact] public void NavigationPropertyTypeParsingShouldProduceErrorIfMalformedCollectionType() { var testSubject = this.ParseNavigation("Collection(FQ.NS.EntityType", null); - testSubject.Errors().Should().HaveCount(1).And.Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedEntityType); - testSubject.Type.FullName().Should().Be("Collection(FQ.NS.EntityType"); + var error = Assert.Single(testSubject.Errors()); + Assert.Equal(EdmErrorCode.BadUnresolvedEntityType, error.ErrorCode); + Assert.Equal("Collection(FQ.NS.EntityType", testSubject.Type.FullName()); } [Fact] public void NavigationPropertyTypeParsingShouldProduceErrorIfElementTypeCannotBeFound() { var testSubject = this.ParseNavigation("Collection(Fake.NonExistent)", null); - testSubject.Errors().Should().HaveCount(1).And.Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedEntityType); - testSubject.Type.IsCollection().Should().BeTrue(); - testSubject.Type.AsCollection().ElementType().FullName().Should().Be("Fake.NonExistent"); + var error = Assert.Single(testSubject.Errors()); + Assert.Equal(EdmErrorCode.BadUnresolvedEntityType, error.ErrorCode); + Assert.True(testSubject.Type.IsCollection()); + Assert.Equal("Fake.NonExistent", testSubject.Type.AsCollection().ElementType().FullName()); } private IEdmNavigationProperty ParseSingleConstraint(string property, string referencedProperty, CsdlLocation location = null) diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationImportTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationImportTests.cs index cf1b535aee..b5b041cb1c 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationImportTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationImportTests.cs @@ -7,7 +7,6 @@ using System.Collections.ObjectModel; using System.ComponentModel; using System.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; @@ -22,7 +21,7 @@ public class CsdlSemanticsOperationImportTests public CsdlSemanticsOperationImportTests() { - this.testLocation = new CsdlLocation(1, 3); + this.testLocation = new CsdlLocation(1, 3); } [Fact] @@ -37,12 +36,12 @@ public void EnsureEntitySetResolvesToEdmPathExpression() var csdlSemanticEntityContainer = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var semanticActionImport = new CsdlSemanticsActionImport(csdlSemanticEntityContainer, actionImport, semanticAction); - semanticActionImport.Action.Should().NotBeNull(); - semanticActionImport.Action.Name.Should().Be("Checkout"); + Assert.NotNull(semanticActionImport.Action); + Assert.Equal("Checkout", semanticActionImport.Action.Name); var pathExpression = (IEdmPathExpression)semanticActionImport.EntitySet; var items = pathExpression.PathSegments.ToList(); - items[0].Should().Be("Nav1"); - items[1].Should().Be("Nav2"); + Assert.Equal("Nav1", items[0]); + Assert.Equal("Nav2", items[1]); } [Fact] @@ -57,12 +56,12 @@ public void CsdlSemanticsActionImportPropertiesShouldBeInitializedCorrectly() var csdlSemanticEntityContainer = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var semanticActionImport = new CsdlSemanticsActionImport(csdlSemanticEntityContainer, actionImport, semanticAction); - semanticActionImport.Action.Should().NotBeNull(); - semanticActionImport.Action.Name.Should().Be("Checkout"); - semanticActionImport.Container.Name.Should().Be("Container"); - semanticActionImport.Location().Should().Be(testLocation); - semanticActionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); - semanticActionImport.EntitySet.Should().BeNull(); + Assert.NotNull(semanticActionImport.Action); + Assert.Equal("Checkout", semanticActionImport.Action.Name); + Assert.Equal("Container", semanticActionImport.Container.Name); + Assert.Equal(testLocation, semanticActionImport.Location()); + Assert.Equal(EdmContainerElementKind.ActionImport, semanticActionImport.ContainerElementKind); + Assert.Null(semanticActionImport.EntitySet); } [Fact] @@ -79,13 +78,13 @@ public void CsdlSemanticsFunctionImportPropertiesShouldBeInitializedCorrectly() var csdlSemanticEntityContainer = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var semanticActionImport = new CsdlSemanticsFunctionImport(csdlSemanticEntityContainer, functionImport, semanticFunction); - semanticActionImport.Function.Should().NotBeNull(); - semanticActionImport.Function.Name.Should().Be("GetStuff"); - semanticActionImport.Container.Name.Should().Be("Container"); - semanticActionImport.Location().Should().Be(testLocation); - semanticActionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.FunctionImport); - semanticActionImport.EntitySet.Should().BeNull(); - semanticActionImport.IncludeInServiceDocument.Should().BeTrue(); + Assert.NotNull(semanticActionImport.Function); + Assert.Equal("GetStuff", semanticActionImport.Function.Name); + Assert.Equal("Container", semanticActionImport.Container.Name); + Assert.Equal(testLocation, semanticActionImport.Location()); + Assert.Equal(EdmContainerElementKind.FunctionImport, semanticActionImport.ContainerElementKind); + Assert.Null(semanticActionImport.EntitySet); + Assert.True(semanticActionImport.IncludeInServiceDocument); } private static CsdlSemanticsSchema CreateCsdlSemanticsSchema(CsdlEntityContainer csdlEntityContainer, params CsdlOperation[] operations) diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationTests.cs index 87b85bd3fd..26200d4aca 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsOperationTests.cs @@ -5,11 +5,9 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Vocabularies; using Xunit; @@ -49,14 +47,14 @@ public void NonBoundCsdlSemanticsOperationPropertiesShouldBeCorrect() testLocation); var semanticFunction = new CsdlSemanticsFunction(this.semanticSchema, function); - semanticFunction.IsBound.Should().BeFalse(); - semanticFunction.Location().Should().Be(testLocation); - semanticFunction.Name.Should().Be("Checkout"); - semanticFunction.Namespace.Should().Be("FQ.NS"); - semanticFunction.ReturnType.Definition.Should().Be(EdmCoreModel.Instance.GetString(true).Definition); - semanticFunction.EntitySetPath.Should().BeNull(); - semanticFunction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Function); - semanticFunction.IsComposable.Should().BeTrue(); + Assert.False(semanticFunction.IsBound); + Assert.Equal(testLocation, semanticFunction.Location()); + Assert.Equal("Checkout", semanticFunction.Name); + Assert.Equal("FQ.NS", semanticFunction.Namespace); + Assert.Equal("Edm.String", semanticFunction.ReturnType.Definition.FullTypeName()); + Assert.Null(semanticFunction.EntitySetPath); + Assert.Equal(EdmSchemaElementKind.Function, semanticFunction.SchemaElementKind); + Assert.True(semanticFunction.IsComposable); } [Fact] @@ -71,14 +69,14 @@ public void BoundCsdlSemanticsOperationPropertiesShouldBeCorrect() testLocation); var semanticAction = new CsdlSemanticsAction(this.semanticSchema, action); - semanticAction.IsBound.Should().BeTrue(); - semanticAction.Location().Should().Be(testLocation); - semanticAction.Name.Should().Be("Checkout"); - semanticAction.Namespace.Should().Be("FQ.NS"); - semanticAction.ReturnType.Definition.Should().Be(EdmCoreModel.Instance.GetString(true).Definition); - semanticAction.EntitySetPath.PathSegments.ToList()[0].Should().Be("entity"); - semanticAction.EntitySetPath.PathSegments.ToList()[1].Should().Be("FakePath"); - semanticAction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action); + Assert.True(semanticAction.IsBound); + Assert.Equal(testLocation, semanticAction.Location()); + Assert.Equal("Checkout", semanticAction.Name); + Assert.Equal("FQ.NS", semanticAction.Namespace); + Assert.Equal("Edm.String", semanticAction.ReturnType.Definition.FullTypeName()); + Assert.Equal("entity", semanticAction.EntitySetPath.PathSegments.ToList()[0]); + Assert.Equal("FakePath", semanticAction.EntitySetPath.PathSegments.ToList()[1]); + Assert.Equal(EdmSchemaElementKind.Action, semanticAction.SchemaElementKind); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsTypeDefinitionDefinitionTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsTypeDefinitionDefinitionTests.cs index 99df3dc234..5c78ca6171 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsTypeDefinitionDefinitionTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Semantics/CsdlSemanticsTypeDefinitionDefinitionTests.cs @@ -4,7 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; @@ -19,11 +18,11 @@ public void CsdlSemanticsTypeDefinitionDefinitionUnitTest() { CsdlTypeDefinition typeDefinition = new CsdlTypeDefinition("Length", "Edm.String", new CsdlLocation(5, 6)); CsdlSemanticsTypeDefinitionDefinition typeDefinitionDefinition = new CsdlSemanticsTypeDefinitionDefinition(null, typeDefinition); - ((IEdmTypeDefinition)typeDefinitionDefinition).UnderlyingType.PrimitiveKind.Should().Be(EdmPrimitiveTypeKind.String); - ((IEdmSchemaElement)typeDefinitionDefinition).SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - ((IEdmNamedElement)typeDefinitionDefinition).Name.Should().Be("Length"); - typeDefinitionDefinition.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - typeDefinitionDefinition.Element.Should().Be(typeDefinition); + Assert.Equal(EdmPrimitiveTypeKind.String, ((IEdmTypeDefinition)typeDefinitionDefinition).UnderlyingType.PrimitiveKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, ((IEdmSchemaElement)typeDefinitionDefinition).SchemaElementKind); + Assert.Equal("Length", ((IEdmNamedElement)typeDefinitionDefinition).Name); + Assert.Equal(EdmTypeKind.TypeDefinition, typeDefinitionDefinition.TypeKind); + Assert.Equal(typeDefinition, typeDefinitionDefinition.Element); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSchemaWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSchemaWriterTests.cs index dfc90d8556..d85aab40ea 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSchemaWriterTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSchemaWriterTests.cs @@ -7,7 +7,6 @@ using System; using System.IO; using System.Xml; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.Serialization; using Microsoft.OData.Edm.Vocabularies; @@ -88,7 +87,9 @@ public void ValidateIncorrectEdmExpressionThrows() EdmActionImport actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmIntegerConstant(EdmCoreModel.Instance.GetInt32(true), 1)); Action errorTest = () => CreateEdmModelCsdlSchemaWriterForErrorTest().WriteActionImportElementHeader(actionImport); - errorTest.ShouldThrow().WithMessage(Strings.EdmModel_Validator_Semantic_OperationImportEntitySetExpressionIsInvalid(actionImport.Name)); + + var exception = Assert.Throws(errorTest); + Assert.Equal(Strings.EdmModel_Validator_Semantic_OperationImportEntitySetExpressionIsInvalid(actionImport.Name), exception.Message); } private void TestWriteActionImportElementHeaderMethod(IEdmActionImport actionImport, string expected) diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/EdmUtilTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/EdmUtilTests.cs index 3056363c3c..226d7550f3 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/EdmUtilTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/EdmUtilTests.cs @@ -4,8 +4,6 @@ // //--------------------------------------------------------------------- - -using FluentAssertions; using Xunit; namespace Microsoft.OData.Edm.Tests @@ -21,14 +19,14 @@ public void FunctionImportShouldProduceCorrectFullyQualifiedNameAndNotHaveParame var function = new EdmFunction("d.s", "testFunction", EdmCoreModel.Instance.GetString(true)); function.AddParameter("param1", EdmCoreModel.Instance.GetString(false)); var functionImport = new EdmFunctionImport(new EdmEntityContainer("d.s", "container"), "testFunction", function); - EdmUtil.FullyQualifiedName(functionImport).Should().Be("d.s.container/testFunction"); + Assert.Equal("d.s.container/testFunction", EdmUtil.FullyQualifiedName(functionImport)); } [Fact] public void EntitySetShouldProduceCorrectFullyQualifiedName() { var entitySet = new EdmEntitySet(new EdmEntityContainer("d.s", "container"), "entitySet", new EdmEntityType("foo", "type")); - EdmUtil.FullyQualifiedName(entitySet).Should().Be("d.s.container/entitySet"); + Assert.Equal("d.s.container/entitySet", EdmUtil.FullyQualifiedName(entitySet)); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ExtensionMethods/ExtensionMethodTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ExtensionMethods/ExtensionMethodTests.cs index 586a8513be..2d2cd602fc 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ExtensionMethods/ExtensionMethodTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ExtensionMethods/ExtensionMethodTests.cs @@ -7,13 +7,10 @@ using System; using System.Collections.Generic; using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Csdl.CsdlSemantics; using Microsoft.OData.Edm.Csdl.Parsing.Ast; using Microsoft.OData.Edm.Vocabularies; -using Microsoft.OData.Edm.Tests; using Microsoft.OData.Edm.Tests.Validation; using Microsoft.OData.Edm.Validation; using Xunit; @@ -42,7 +39,7 @@ public void OperationTypeIsSameAsBindingShouldReturnTrue() { EdmAction action = new EdmAction("n", "a", null, true, null); action.AddParameter("bindingParameter", DefaultValidEntityTypeRef); - action.HasEquivalentBindingType(DefaultValidEntityType).Should().BeTrue(); + Assert.True(action.HasEquivalentBindingType(DefaultValidEntityType)); } [Fact] @@ -50,7 +47,7 @@ public void OperationTypeIsSameCollectionTypeAsBindingShouldReturnTrue() { EdmAction action = new EdmAction("n", "a", null, true, null); action.AddParameter("bindingParameter", DefaultValidCollectionEntityTypeRef); - action.HasEquivalentBindingType(DefaultValidCollectionEntityTypeRef.Definition).Should().BeTrue(); + Assert.True(action.HasEquivalentBindingType(DefaultValidCollectionEntityTypeRef.Definition)); } [Fact] @@ -58,7 +55,7 @@ public void OperationTypeIsSameAsWithBaseBindingShouldReturnFalse() { EdmAction action = new EdmAction("n", "a", null, true, null); action.AddParameter("bindingParameter", DefaultDerivedValidEntityTypeRef); - action.HasEquivalentBindingType(DefaultValidEntityType).Should().BeFalse(); + Assert.False(action.HasEquivalentBindingType(DefaultValidEntityType)); } [Fact] @@ -66,7 +63,7 @@ public void OperationTypeIsSameCollectionTypeAsWithBaseBindingShouldReturnFalse( { EdmAction action = new EdmAction("n", "a", null, true, null); action.AddParameter("bindingParameter", DefaultDerivedValidCollectionEntityTypeRef); - action.HasEquivalentBindingType(DefaultValidCollectionEntityTypeRef.Definition).Should().BeFalse(); + Assert.False(action.HasEquivalentBindingType(DefaultValidCollectionEntityTypeRef.Definition)); } #endregion @@ -75,7 +72,7 @@ public void OperationTypeIsSameCollectionTypeAsWithBaseBindingShouldReturnFalse( public void ForceFilterByFullNameShouldReturnNoOperations() { EdmAction action = new EdmAction("namespace", "action", null); - new IEdmOperation[] { action }.FilterByName(true, "action").Should().BeEmpty(); + Assert.Empty(new IEdmOperation[] { action }.FilterByName(true, "action")); } [Fact] @@ -83,15 +80,15 @@ public void FilterByNameShouldThrowIfOperationNameNull() { EdmAction action = new EdmAction("namespace", "action", null); Action test = () => new IEdmOperation[] { action }.FilterByName(true, null); - test.ShouldThrow(); + Assert.Throws("operationName", test); } [Fact] public void FilterByNameShouldThrowIfSequenceNull() { EdmAction action = new EdmAction("namespace", "action", null); - Action test = () => Microsoft.OData.Edm.ExtensionMethods.FilterByName(null, true, "action"); - test.ShouldThrow(); + Action test = () => Edm.ExtensionMethods.FilterByName(null, true, "action"); + Assert.Throws("operations", test); } [Fact] @@ -99,7 +96,7 @@ public void FilterByPartialNameShouldReturnBothActionsWithDifferenceNamespacesBu { EdmAction action = new EdmAction("namespace", "action", null); EdmAction action2 = new EdmAction("namespace2", "action", null); - new IEdmOperation[] { action, action2 }.FilterByName(false, "action").Should().HaveCount(2); + Assert.Equal(2, new IEdmOperation[] { action, action2 }.FilterByName(false, "action").Count()); } [Fact] @@ -108,8 +105,8 @@ public void FilterByFullNameShouldReturnOneActionsWithCorrectNamespace() EdmAction action = new EdmAction("namespace", "action", null); EdmAction action2 = new EdmAction("namespace2", "action", null); var filteredResults = new IEdmOperation[] { action, action2 }.FilterByName(false, "namespace.action").ToList(); - filteredResults.Should().HaveCount(1); - filteredResults[0].Should().Be(action); + var filter = Assert.Single(filteredResults); + Assert.Same(action, filter); } #endregion @@ -121,14 +118,14 @@ public void ShortQualifiedNameForNonPrimitiveTypeShouldBeFullName() string stringOfExpectedShortQualifiedName = String.Format("{0}.{1}", DefaultNamespace, DefaultName); var stringOfObservedShortQualifiedName = edmComplexType.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().Be(stringOfExpectedShortQualifiedName); + Assert.Equal(stringOfExpectedShortQualifiedName, stringOfObservedShortQualifiedName); stringOfObservedShortQualifiedName = edmEntityType.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().Be(stringOfExpectedShortQualifiedName); + Assert.Equal(stringOfExpectedShortQualifiedName, stringOfObservedShortQualifiedName); var edmEntityContainer = new EdmEntityContainer(DefaultNamespace, DefaultName); stringOfObservedShortQualifiedName = edmEntityContainer.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().Be(stringOfExpectedShortQualifiedName); + Assert.Equal(stringOfExpectedShortQualifiedName, stringOfObservedShortQualifiedName); } [Fact] @@ -136,11 +133,11 @@ public void ShortQualifiedNameForCollectionNonPrimitiveTypeShouldBeNull() { var iEdmCollectionTypeReference = EdmCoreModel.GetCollection(new EdmComplexTypeReference(edmComplexType, true)); var stringOfObservedShortQualifiedName = iEdmCollectionTypeReference.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().BeNull(); + Assert.Null(stringOfObservedShortQualifiedName); iEdmCollectionTypeReference = EdmCoreModel.GetCollection(new EdmEntityTypeReference(edmEntityType, true)); stringOfObservedShortQualifiedName = iEdmCollectionTypeReference.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().BeNull(); + Assert.Null(stringOfObservedShortQualifiedName); } [Fact] @@ -151,9 +148,9 @@ public void ShortQualifiedNameForPrimitiveTypeShouldBeName() if (EdmPrimitiveTypeKind.None == edmPrimitiveTypeKind) continue; var stringOfExpectedShortQualifiedName = Enum.GetName(typeof(EdmPrimitiveTypeKind), edmPrimitiveTypeKind); - stringOfExpectedShortQualifiedName.ToUpper().Should().NotContain("EDM."); + Assert.DoesNotContain("EDM.", stringOfExpectedShortQualifiedName.ToUpper()); var stringOfObservedShortQualifiedName = EdmCoreModel.Instance.GetPrimitiveType(edmPrimitiveTypeKind).ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().Be(stringOfExpectedShortQualifiedName); + Assert.Equal(stringOfExpectedShortQualifiedName, stringOfObservedShortQualifiedName); } } @@ -165,13 +162,13 @@ public void ShortQualifiedNameForCollectionPrimitiveTypeShouldBeNull() if (EdmPrimitiveTypeKind.None == edmPrimitiveTypeKind) continue; var stringOfName = Enum.GetName(typeof(EdmPrimitiveTypeKind), edmPrimitiveTypeKind); - stringOfName.ToUpper().Should().NotContain("EDM."); + Assert.DoesNotContain("EDM.", stringOfName.ToUpper()); var iEdmPrimitiveType = EdmCoreModel.Instance.GetPrimitiveType(edmPrimitiveTypeKind); var edmCollectionType = EdmCoreModel.GetCollection(new EdmPrimitiveTypeReference(iEdmPrimitiveType, true)); var stringOfObservedShortQualifiedName = edmCollectionType.ShortQualifiedName(); - stringOfObservedShortQualifiedName.Should().BeNull(); + Assert.Null(stringOfObservedShortQualifiedName); } } #endregion @@ -180,7 +177,7 @@ public void ShortQualifiedNameForCollectionPrimitiveTypeShouldBeNull() public void FullTypeNameAndFullNameIEdmTypeReferenceShouldBeEqual() { var enumType = new EdmEnumTypeReference(new EdmEnumType("n", "enumtype"), false); - enumType.FullName().Should().Be(enumType.Definition.FullTypeName()); + Assert.Equal(enumType.Definition.FullTypeName(), enumType.FullName()); } #region IEdmType FullName tests @@ -189,42 +186,42 @@ public void FullTypeNameAndFullNameIEdmTypeReferenceShouldBeEqual() public void CollectionUnNamedStructuralType() { var fakeStructuredCollectionType = EdmCoreModel.GetCollection(new FakeEdmStructuredTypeReference(new FakeStructuredType(false, false, null))); - fakeStructuredCollectionType.Definition.FullTypeName().Should().BeNull(); + Assert.Null(fakeStructuredCollectionType.Definition.FullTypeName()); } [Fact] public void UnNamedStructuralType() { var fakeStructuredType = new FakeEdmStructuredTypeReference(new FakeStructuredType(false, false, null)); - fakeStructuredType.Definition.FullTypeName().Should().BeNull(); + Assert.Null(fakeStructuredType.Definition.FullTypeName()); } [Fact] public void EnumTypeReferenceFullNameTest() { var enumType = new EdmEnumType("n", "enumtype"); - enumType.FullTypeName().Should().Be("n.enumtype"); + Assert.Equal("n.enumtype", enumType.FullTypeName()); } [Fact] public void CollectionPrimitiveTypeReferenceFullNameTest() { var collectionPrimitives = EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt16(true)); - collectionPrimitives.Definition.FullTypeName().Should().Be("Collection(Edm.Int16)"); + Assert.Equal("Collection(Edm.Int16)", collectionPrimitives.Definition.FullTypeName()); } [Fact] public void CollectionEntityTypeTypeReferenceFullNameTest() { var entityTypeCollection = EdmCoreModel.GetCollection(new EdmEntityTypeReference(new EdmEntityType("n", "type"), false)); - entityTypeCollection.Definition.FullTypeName().Should().Be("Collection(n.type)"); + Assert.Equal("Collection(n.type)", entityTypeCollection.Definition.FullTypeName()); } [Fact] public void PrimitiveTypeReferenceFullNameTest() { var primitiveTypeReference = EdmCoreModel.Instance.GetInt16(true); - primitiveTypeReference.Definition.FullTypeName().Should().Be("Edm.Int16"); + Assert.Equal("Edm.Int16", primitiveTypeReference.Definition.FullTypeName()); } [Fact] @@ -243,7 +240,7 @@ public void GetReturnShouldReturnCorrectly() public void EntityTypeTypeReferenceFullNameTest() { var entityType = new EdmEntityType("n", "type"); - entityType.FullTypeName().Should().Be("n.type"); + Assert.Equal("n.type", entityType.FullTypeName()); } #endregion @@ -252,8 +249,8 @@ public void EntityTypeTypeReferenceFullNameTest() public void EdmFunctionShouldBeFunction() { var function = new EdmFunction("d.s", "checkout", EdmCoreModel.Instance.GetString(true)); - function.IsAction().Should().BeFalse(); - function.IsFunction().Should().BeTrue(); + Assert.False(function.IsAction()); + Assert.True(function.IsFunction()); } [Fact] @@ -261,8 +258,8 @@ public void EdmActionImportShouldBeActionImport() { var action = new EdmAction("d.s", "checkout", null); var actionImport = new EdmActionImport(new EdmEntityContainer("d", "c"), "checkout", action); - actionImport.IsActionImport().Should().BeTrue(); - actionImport.IsFunctionImport().Should().BeFalse(); + Assert.True(actionImport.IsActionImport()); + Assert.False(actionImport.IsFunctionImport()); } @@ -271,8 +268,8 @@ public void EdmFunctionImportShouldBeFunctionImport() { var function = new EdmFunction("d.s", "checkout", EdmCoreModel.Instance.GetString(true)); var functionImport = new EdmFunctionImport(new EdmEntityContainer("d", "c"), "checkout", function); - functionImport.IsActionImport().Should().BeFalse(); - functionImport.IsFunctionImport().Should().BeTrue(); + Assert.False(functionImport.IsActionImport()); + Assert.True(functionImport.IsFunctionImport()); } [Fact] @@ -295,8 +292,11 @@ public void EdmNavigationPropertyPrincipalPropertiesShouldReturnPrincipalPropert }; EdmNavigationProperty navProp = type.AddUnidirectionalNavigation(navInfo1); - navProp.PrincipalProperties().Should().NotBeNull(); - navProp.PrincipalProperties().ShouldAllBeEquivalentTo(new[] { key, notKey }); + Assert.NotNull(navProp.PrincipalProperties()); + var properties = navProp.PrincipalProperties(); + Assert.Equal(2, properties.Count()); + Assert.Same(key, properties.First()); + Assert.Same(notKey, properties.Last()); } [Fact] @@ -304,7 +304,7 @@ public void TypeDefinitionUnitTest() { EdmTypeDefinition typeDef = new EdmTypeDefinition("NS", "Length", EdmPrimitiveTypeKind.Int32); EdmTypeDefinitionReference typeRef = new EdmTypeDefinitionReference(typeDef, true); - typeRef.TypeDefinition().Should().Be(typeDef); + Assert.Same(typeDef, typeRef.TypeDefinition()); } #region TryGetRelativeEntitySet OperationaImport Tests @@ -322,10 +322,11 @@ public void ValidateCorrectNoEntitySetPathOnOperationImport() IEdmOperationParameter operationParameter = null; Dictionary navigationProperties = null; - functionImport.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out errorsFound).Should().BeFalse(); - errorsFound.ToList().Should().HaveCount(0); - operationParameter.Should().BeNull(); - navigationProperties.Should().BeNull(); + var result = functionImport.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out errorsFound); + Assert.False(result); + Assert.Empty(errorsFound); + Assert.Null(operationParameter); + Assert.Null(navigationProperties); } [Fact] @@ -341,13 +342,13 @@ public void ValidateCorrectEntitySetPathOnOperationImport() IEdmOperationParameter operationParameter = null; Dictionary navigationProperties = null; - functionImport.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out errorsFound).Should().BeTrue(); - errorsFound.ToList().Should().HaveCount(0); - operationParameter.Should().NotBeNull(); - navigationProperties.Should().HaveCount(0); + var result = functionImport.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out errorsFound); + Assert.True(result); + Assert.Empty(errorsFound); + Assert.NotNull(operationParameter); + Assert.Empty(navigationProperties); } - #endregion #region TryGetRelativeEntitySet Operation Tests @@ -365,10 +366,11 @@ public void TryGetRelativeEntitySetWithNullEntitySetPathShouldReturnFalseAndHave Dictionary navigationProperties = null; IEdmEntityType entityType = null; - function.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound).Should().BeFalse(); - errorsFound.Should().HaveCount(0); - operationParameter.Should().BeNull(); - navigationProperties.Should().BeNull(); + var result = function.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); + Assert.False(result); + Assert.Empty(errorsFound); + Assert.Null(operationParameter); + Assert.Null(navigationProperties); } [Fact] @@ -384,11 +386,12 @@ public void TryGetRelativeEntitySetWithJustBindingParameterShouldReturnTrueAndHa Dictionary navigationProperties = null; IEdmEntityType entityType = null; - function.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound).Should().BeTrue(); - errorsFound.Should().HaveCount(0); - operationParameter.Should().NotBeNull(); - navigationProperties.Should().HaveCount(0); - entityType.Should().Be(DefaultValidEntityTypeRef.Definition); + var result = function.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); + Assert.True(result); + Assert.Empty(errorsFound); + Assert.NotNull(operationParameter); + Assert.Empty(navigationProperties); + Assert.Same(DefaultValidEntityTypeRef.Definition, entityType); } [Fact] @@ -416,11 +419,12 @@ public void TryGetEntitySetWithBoundCsdlSemanticOperationParameterShouldReturnTr Dictionary navigationProperties; IEdmEntityType entityType; IEnumerable errors; - semanticAction.TryGetRelativeEntitySetPath(semanticSchema.Model, out edmParameter, out navigationProperties, out entityType, out errors).Should().BeTrue(); - edmParameter.Name.Should().Be("entity"); - navigationProperties.Should().BeEmpty(); - entityType.FullName().Should().Be("FQ.NS.EntityType"); - errors.Should().BeEmpty(); + var result = semanticAction.TryGetRelativeEntitySetPath(semanticSchema.Model, out edmParameter, out navigationProperties, out entityType, out errors); + Assert.True(result); + Assert.Equal("entity", edmParameter.Name); + Assert.Empty(navigationProperties); + Assert.Equal("FQ.NS.EntityType", entityType.FullName()); + Assert.Empty(errors); } [Fact] @@ -715,7 +719,7 @@ private static void ValidateNoError(IEdmModel model, IEdmOperation operation) IEdmEntityType entityType = null; operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); - errorsFound.Should().HaveCount(0); + Assert.Empty(errorsFound); } private static void ValidateError(IEdmModel model, IEdmOperation operation, EdmErrorCode expectedErrorCode, string expectedError) @@ -726,10 +730,9 @@ private static void ValidateError(IEdmModel model, IEdmOperation operation, EdmE IEdmEntityType entityType = null; operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); - errorsFound.Should().HaveCount(1); - var errorsFoundList = errorsFound.ToList(); - errorsFoundList[0].ErrorCode.Should().Be(expectedErrorCode); - errorsFoundList[0].ErrorMessage.Should().Be(expectedError); + var error = Assert.Single(errorsFound); + Assert.Equal(expectedErrorCode, error.ErrorCode); + Assert.Equal(expectedError, error.ErrorMessage); } private static void ValidateErrorInList(IEdmModel model, IEdmOperation operation, EdmErrorCode expectedErrorCode, string expectedError) @@ -741,112 +744,111 @@ private static void ValidateErrorInList(IEdmModel model, IEdmOperation operation operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); var error = errorsFound.SingleOrDefault(e => e.ErrorCode == expectedErrorCode); - error.Should().NotBeNull(); - error.ErrorMessage.Should().Be(expectedError); + Assert.NotNull(error); + Assert.Equal(expectedError, error.ErrorMessage); } #endregion - #region [Fact] public void CheckExistingContainer() { - TestModel.Instance.Model.ExistsContainer(TestModel.Instance.Container.Name).Should().BeTrue(); + Assert.True(TestModel.Instance.Model.ExistsContainer(TestModel.Instance.Container.Name)); } [Fact] public void CheckExistingContainerWithQualifiedName() { - TestModel.Instance.Model.ExistsContainer(TestModel.Instance.Container.ShortQualifiedName()).Should().BeTrue(); + Assert.True(TestModel.Instance.Model.ExistsContainer(TestModel.Instance.Container.ShortQualifiedName())); } [Fact] public void CheckNonExistingContainer() { var containerName = "NonExistingContainer"; - TestModel.Instance.Model.ExistsContainer(containerName).Should().BeFalse(); + Assert.False(TestModel.Instance.Model.ExistsContainer(containerName)); } [Fact] public void FindDeclaredEntitySet() { var entitySet = TestModel.Instance.Model.FindDeclaredEntitySet(TestModel.Instance.EntitySet.Name); - entitySet.Should().NotBeNull(); - entitySet.EntityType().Should().Equals(TestModel.Instance.EntitySet.EntityType()); + Assert.NotNull(entitySet); + Assert.Same(TestModel.Instance.EntitySet.EntityType(), entitySet.EntityType()); } [Fact] public void FindDeclaredEntitySetWithContainerName() { var entitySet = TestModel.Instance.Model.FindDeclaredEntitySet(TestModel.Instance.Container.Name + "." + TestModel.Instance.EntitySet.Name); - entitySet.Should().NotBeNull(); - entitySet.EntityType().Should().Equals(TestModel.Instance.EntitySet.EntityType()); + Assert.NotNull(entitySet); + Assert.Same(TestModel.Instance.EntitySet.EntityType(), entitySet.EntityType()); } [Fact] public void FindDeclaredEntitySetWithContainerQualifiedName() { var entitySet = TestModel.Instance.Model.FindDeclaredEntitySet(TestModel.Instance.Container.ShortQualifiedName() + "." + TestModel.Instance.EntitySet.Name); - entitySet.Should().NotBeNull(); - entitySet.EntityType().Should().Equals(TestModel.Instance.EntitySet.EntityType()); + Assert.NotNull(entitySet); + Assert.Same(TestModel.Instance.EntitySet.EntityType(), entitySet.EntityType()); } [Fact] public void FindDeclaredEntitySetWithNonExistingEntitySetName() { var entitySetName = "NonExistingEntitySet"; - TestModel.Instance.Model.FindDeclaredEntitySet(entitySetName).Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindDeclaredEntitySet(entitySetName)); } [Fact] public void FindDeclaredEntitySetWithSingletonName() { - TestModel.Instance.Model.FindDeclaredEntitySet(TestModel.Instance.Singleton.Name).Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindDeclaredEntitySet(TestModel.Instance.Singleton.Name)); } [Fact] public void FindDeclaredSingleton() { var singleton = TestModel.Instance.Model.FindDeclaredSingleton(TestModel.Instance.Singleton.Name); - singleton.Should().NotBeNull(); - singleton.EntityType().Should().Equals(TestModel.Instance.Singleton.EntityType()); + Assert.NotNull(singleton); + Assert.Same(TestModel.Instance.Singleton.EntityType(), singleton.EntityType()); } [Fact] public void FindDeclaredSingletonWithContainerName() { var singleton = TestModel.Instance.Model.FindDeclaredSingleton(TestModel.Instance.Container.Name + "." + TestModel.Instance.Singleton.Name); - singleton.Should().NotBeNull(); - singleton.EntityType().Should().Equals(TestModel.Instance.Singleton.EntityType()); + Assert.NotNull(singleton); + Assert.Same(TestModel.Instance.Singleton.EntityType(), singleton.EntityType()); } [Fact] public void FindDeclaredSingletonWithContainerQualifiedName() { var singleton = TestModel.Instance.Model.FindDeclaredSingleton(TestModel.Instance.Container.ShortQualifiedName() + "." + TestModel.Instance.Singleton.Name); - singleton.Should().NotBeNull(); - singleton.EntityType().Should().Equals(TestModel.Instance.Singleton.EntityType()); + Assert.NotNull(singleton); + Assert.Same(TestModel.Instance.Singleton.EntityType(), singleton.EntityType()); } [Fact] public void FindDeclaredSingletonWithNonExistingSingletonName() { var singletonName = "NonExistingSingleton"; - TestModel.Instance.Model.FindDeclaredSingleton(singletonName).Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindDeclaredSingleton(singletonName)); } [Fact] public void FindDeclaredSingletonWithEntitySetName() { - TestModel.Instance.Model.FindDeclaredSingleton(TestModel.Instance.EntitySet.Name).Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindDeclaredSingleton(TestModel.Instance.EntitySet.Name)); } [Fact] public void FindDeclaredOperationImports() { var operationImport = TestModel.Instance.Model.FindDeclaredOperationImports(TestModel.Instance.functionImport.Name); - operationImport.Should().HaveCount(1); - operationImport.ElementAt(0).IsFunctionImport().Should().BeTrue(); + Assert.Single(operationImport); + Assert.True(operationImport.ElementAt(0).IsFunctionImport()); } [Fact] @@ -854,8 +856,8 @@ public void FindDeclaredOperationImportsWithContainerName() { var operationImportName = TestModel.Instance.Container.Name + "." + TestModel.Instance.functionImport.Name; var operationImport = TestModel.Instance.Model.FindDeclaredOperationImports(operationImportName); - operationImport.Should().NotBeNull(); - operationImport.ElementAt(0).IsFunctionImport().Should().BeTrue(); + Assert.NotNull(operationImport); + Assert.True(operationImport.ElementAt(0).IsFunctionImport()); } [Fact] @@ -863,51 +865,52 @@ public void FindDeclaredOperationImportsWithContainerQualifiedName() { var operationImportName = TestModel.Instance.Container.ShortQualifiedName() + "." + TestModel.Instance.functionImport.Name; var operationImport = TestModel.Instance.Model.FindDeclaredOperationImports(operationImportName); - operationImport.Should().NotBeNull(); - operationImport.ElementAt(0).IsFunctionImport().Should().BeTrue(); + Assert.NotNull(operationImport); + Assert.True(operationImport.ElementAt(0).IsFunctionImport()); } [Fact] public void FindDeclaredOperationImportsWithNonExistingOperationImportsName() { var operationImportName = "NonExistingOperationImports"; - TestModel.Instance.Model.FindDeclaredOperationImports(operationImportName).Should().HaveCount(0); + var result = TestModel.Instance.Model.FindDeclaredOperationImports(operationImportName); + Assert.Empty(result); } [Fact] public void FindTypeByAliasName() { - TestModel.Instance.Model.FindType("TestModelAlias.T1").FullName().Should().Be("TestModelNameSpace.T1"); + Assert.Equal("TestModelNameSpace.T1", TestModel.Instance.Model.FindType("TestModelAlias.T1").FullName()); } [Fact] public void FindTypeBySinglePartNamespaceQualifiedName() { - TestModel.Instance.Model.FindType("TestModelNameSpace.T1").FullName().Should().Be("TestModelNameSpace.T1"); + Assert.Equal("TestModelNameSpace.T1", TestModel.Instance.Model.FindType("TestModelNameSpace.T1").FullName()); } [Fact] public void FindTypeByMultiPartAliasQualfiedName() { - TestModel.Instance.Model.FindType("MultipartTestModelAlias.E1").FullName().Should().Be("Multi.Part.TestModelNameSpace.E1"); + Assert.Equal("Multi.Part.TestModelNameSpace.E1", TestModel.Instance.Model.FindType("MultipartTestModelAlias.E1").FullName()); } [Fact] public void FindUndefinedAliasQualifiedNameReturnsNull() { - TestModel.Instance.Model.FindType("MultipartTestModelAlias.T1").Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindType("MultipartTestModelAlias.T1")); } [Fact] public void FindUndefinedSinglePartNamespaceQualifiedNameReturnsNull() { - TestModel.Instance.Model.FindType("TestModelNameSpace.E1").Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindType("TestModelNameSpace.E1")); } [Fact] public void FindUndefinedNamespaceQualifiedNameReturnsNull() { - TestModel.Instance.Model.FindType("Multi.Part.TestModelNameSpace.T1").Should().BeNull(); + Assert.Null(TestModel.Instance.Model.FindType("Multi.Part.TestModelNameSpace.T1")); } [Fact] @@ -990,7 +993,6 @@ private TestModel() public EdmFunction functionImport { get; private set; } } - #endregion internal class FakeStructuredType : EdmStructuredType { diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.NetCore.csproj b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.NetCore.csproj index eca35b3c5f..f3de7a13b4 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.NetCore.csproj +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.NetCore.csproj @@ -18,7 +18,6 @@ - diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisActionsFunctionsRelationshipChangesAcceptanceTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisActionsFunctionsRelationshipChangesAcceptanceTests.cs index b3e64a809a..3d6cfe894a 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisActionsFunctionsRelationshipChangesAcceptanceTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisActionsFunctionsRelationshipChangesAcceptanceTests.cs @@ -10,11 +10,9 @@ using System.Text; using System.Xml; using System.Xml.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Validation; using Xunit; -using ErrorStrings = Microsoft.OData.Edm.Strings; namespace Microsoft.OData.Edm.Tests.ScenarioTests { @@ -90,8 +88,8 @@ public DefaultTestModel() { this.RepresentativeModel = CsdlReader.Parse(XElement.Parse(RepresentativeEdmxDocument).CreateReader()); this.EntityContainer = this.RepresentativeModel.EntityContainer; - this.EntityContainer.Should().NotBeNull(); - this.EntityContainer.Name.Should().Be("Container"); + Assert.NotNull(this.EntityContainer); + Assert.Equal("Container", this.EntityContainer.Name); this.AddAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Add").Single(); this.OtherAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Other").Single(); @@ -110,10 +108,10 @@ public DefaultTestModel() this.Get3FunctionImportWithNoParams = (IEdmFunctionImport)get3Imports[1]; this.PersonType = this.RepresentativeModel.FindDeclaredType("Test.Person") as IEdmEntityType; - this.PersonType.Should().NotBeNull(); + Assert.NotNull(this.PersonType); this.CarType = this.RepresentativeModel.FindDeclaredType("Test.Car") as IEdmEntityType; - this.CarType.Should().NotBeNull(); + Assert.NotNull(this.CarType); } public IEdmModel RepresentativeModel { get; private set; } @@ -165,8 +163,8 @@ public void RepresentativeFunctionsModelShouldBeValid() { IEnumerable errors; bool valid = this.TestModel.RepresentativeModel.Validate(out errors); - valid.Should().BeTrue(); - errors.Should().BeEmpty(); + Assert.True(valid); + Assert.Empty(errors); } [Fact] @@ -212,28 +210,27 @@ public void EnsureReadingCsdlResultsInTwoFunctionImportsAndActionImports() var edmModel = CsdlReader.Parse(XElement.Parse(testCsdl).CreateReader()); var operations = edmModel.SchemaElements.OfType().ToList(); - operations.Should().HaveCount(6); + Assert.Equal(6, operations.Count()); var container = edmModel.EntityContainer; var operationImports = container.OperationImports().ToList(); - - // Notice there are only two defined above but there are 4, this is by design. - operationImports.Count.Should().Be(4); - operationImports[0].Name.Should().Be("Post1"); - operationImports[0].Operation.Name.Should().Be("Post1"); - operationImports[0].Operation.Parameters.Count().Should().Be(0); - - operationImports[1].Name.Should().Be("Post1"); - operationImports[1].Operation.Name.Should().Be("Post1"); - operationImports[1].Operation.Parameters.Count().Should().Be(1); - - operationImports[2].Name.Should().Be("Get1"); - operationImports[2].Operation.Name.Should().Be("Get1"); - operationImports[2].Operation.Parameters.Count().Should().Be(0); - - operationImports[3].Name.Should().Be("Get1"); - operationImports[3].Operation.Name.Should().Be("Get1"); - operationImports[3].Operation.Parameters.Count().Should().Be(1); + // Notice there are only two defined above but there are 4, this is by design. + Assert.Equal(4, operationImports.Count); + Assert.Equal("Post1", operationImports[0].Name); + Assert.Equal("Post1", operationImports[0].Operation.Name); + Assert.Empty(operationImports[0].Operation.Parameters); + + Assert.Equal("Post1", operationImports[1].Name); + Assert.Equal("Post1", operationImports[1].Operation.Name); + Assert.Single(operationImports[1].Operation.Parameters); + + Assert.Equal("Get1", operationImports[2].Name); + Assert.Equal("Get1", operationImports[2].Operation.Name); + Assert.Empty(operationImports[2].Operation.Parameters); + + Assert.Equal("Get1", operationImports[3].Name); + Assert.Equal("Get1", operationImports[3].Operation.Name); + Assert.Single(operationImports[3].Operation.Parameters); } [Fact] @@ -273,69 +270,69 @@ public void EnsureOperationReturnTypesAreReadCorrectlyFromCsdl() var edmModel = CsdlReader.Parse(XElement.Parse(testCsdl).CreateReader()); var operations = edmModel.SchemaElements.OfType().ToList(); - operations.Should().HaveCount(8); + Assert.Equal(8, operations.Count()); // Functions - operations[0].Should().BeAssignableTo(); - operations[0].Name.Should().Be("FunctionWithComplexReturnType"); - operations[0].ReturnType.FullName().Should().Be("Test.Complex"); - operations[0].ReturnType.IsNullable.Should().BeFalse(); - - operations[1].Should().BeAssignableTo(); - operations[1].Name.Should().Be("FunctionWithComplexCollectionReturnType"); - operations[1].ReturnType.FullName().Should().Be("Collection(Test.Complex)"); - operations[1].ReturnType.AsCollection().ElementType().IsNullable.Should().BeFalse(); - - operations[2].Should().BeAssignableTo(); - operations[2].Name.Should().Be("FunctionWithPrimitiveReturnType"); - operations[2].ReturnType.FullName().Should().Be("Edm.String"); - operations[2].ReturnType.IsNullable.Should().BeFalse(); - operations[2].ReturnType.AsString().MaxLength.Should().Be(10); - - operations[3].Should().BeAssignableTo(); - operations[3].Name.Should().Be("FunctionWithPrimitiveCollectionReturnType"); - operations[3].ReturnType.FullName().Should().Be("Collection(Edm.String)"); - operations[3].ReturnType.AsCollection().ElementType().IsNullable.Should().BeFalse(); - operations[3].ReturnType.AsCollection().ElementType().AsString().MaxLength.Should().Be(20); + Assert.True(operations[0] is IEdmFunction); + Assert.Equal("FunctionWithComplexReturnType", operations[0].Name); + Assert.Equal("Test.Complex", operations[0].ReturnType.FullName()); + Assert.False(operations[0].ReturnType.IsNullable); + + Assert.True(operations[1] is IEdmFunction); + Assert.Equal("FunctionWithComplexCollectionReturnType", operations[1].Name); + Assert.Equal("Collection(Test.Complex)", operations[1].ReturnType.FullName()); + Assert.False(operations[1].ReturnType.AsCollection().ElementType().IsNullable); + + Assert.True(operations[2] is IEdmFunction); + Assert.Equal("FunctionWithPrimitiveReturnType", operations[2].Name); + Assert.Equal("Edm.String", operations[2].ReturnType.FullName()); + Assert.False(operations[2].ReturnType.IsNullable); + Assert.Equal(10, operations[2].ReturnType.AsString().MaxLength); + + Assert.True(operations[3] is IEdmFunction); + Assert.Equal("FunctionWithPrimitiveCollectionReturnType", operations[3].Name); + Assert.Equal("Collection(Edm.String)", operations[3].ReturnType.FullName()); + Assert.False(operations[3].ReturnType.AsCollection().ElementType().IsNullable); + Assert.Equal(20, operations[3].ReturnType.AsCollection().ElementType().AsString().MaxLength); // Actions - operations[4].Should().BeAssignableTo(); - operations[4].Name.Should().Be("ActionWithComplexReturnType"); - operations[4].ReturnType.FullName().Should().Be("Test.Complex"); - operations[4].ReturnType.IsNullable.Should().BeFalse(); - - operations[5].Should().BeAssignableTo(); - operations[5].Name.Should().Be("ActionWithComplexCollectionReturnType"); - operations[5].ReturnType.FullName().Should().Be("Collection(Test.Complex)"); - operations[5].ReturnType.AsCollection().ElementType().IsNullable.Should().BeFalse(); - - operations[6].Should().BeAssignableTo(); - operations[6].Name.Should().Be("ActionWithPrimitiveReturnType"); - operations[6].ReturnType.FullName().Should().Be("Edm.String"); - operations[6].ReturnType.IsNullable.Should().BeFalse(); - operations[6].ReturnType.AsString().MaxLength.Should().Be(10); - - operations[7].Should().BeAssignableTo(); - operations[7].Name.Should().Be("ActionWithPrimitiveCollectionReturnType"); - operations[7].ReturnType.FullName().Should().Be("Collection(Edm.String)"); - operations[7].ReturnType.AsCollection().ElementType().IsNullable.Should().BeFalse(); - operations[7].ReturnType.AsCollection().ElementType().AsString().MaxLength.Should().Be(20); + Assert.True(operations[4] is IEdmAction); + Assert.Equal("ActionWithComplexReturnType", operations[4].Name); + Assert.Equal("Test.Complex", operations[4].ReturnType.FullName()); + Assert.False(operations[4].ReturnType.IsNullable); + + Assert.True(operations[5] is IEdmAction); + Assert.Equal("ActionWithComplexCollectionReturnType", operations[5].Name); + Assert.Equal("Collection(Test.Complex)", operations[5].ReturnType.FullName()); + Assert.False(operations[5].ReturnType.AsCollection().ElementType().IsNullable); + + Assert.True(operations[6] is IEdmAction); + Assert.Equal("ActionWithPrimitiveReturnType", operations[6].Name); + Assert.Equal("Edm.String", operations[6].ReturnType.FullName()); + Assert.False(operations[6].ReturnType.IsNullable); + Assert.Equal(10, operations[6].ReturnType.AsString().MaxLength); + + Assert.True(operations[7] is IEdmAction); + Assert.Equal("ActionWithPrimitiveCollectionReturnType", operations[7].Name); + Assert.Equal("Collection(Edm.String)", operations[7].ReturnType.FullName()); + Assert.False(operations[7].ReturnType.AsCollection().ElementType().IsNullable); + Assert.Equal(20, operations[7].ReturnType.AsCollection().ElementType().AsString().MaxLength); } [Fact] public void ReturnTypePathReturnsCorrectly() { - this.TestModel.RemoveBadCarAction.ReturnType.Should().NotBeNull(); + Assert.NotNull(this.TestModel.RemoveBadCarAction.ReturnType); var personType = this.TestModel.RemoveBadCarAction.ReturnType.AsCollection().ElementType().Definition; - personType.Should().Be(this.TestModel.CarType); + Assert.Equal(this.TestModel.CarType, personType); } [Fact] public void EntitySetPathReturnsCorrectly() { var paths = this.TestModel.RemoveBadCarAction.EntitySetPath.PathSegments.ToList(); - paths[0].Should().Be("People"); - paths[1].Should().Be("Cars"); + Assert.Equal("People", paths[0]); + Assert.Equal("Cars", paths[1]); } [Fact] @@ -354,11 +351,11 @@ public void ValidateEntitySetPathExpressionCannotHaveValueWhenActionNonBound() IEdmModel model = null; IEnumerable errors = null; var errorParsing = CsdlReader.TryParse(XElement.Parse(errorDocument).CreateReader(), out model, out errors); - errorParsing.Should().BeFalse(); + Assert.False(errorParsing); var errorsList = errors.ToList(); - errorsList.Should().HaveCount(1); - errorsList[0].ErrorCode.Should().Be(EdmErrorCode.InvalidEntitySetPath); - errorsList[0].ErrorMessage.Should().Be(Strings.CsdlParser_InvalidEntitySetPathWithUnboundAction(CsdlConstants.Element_Action, "Add")); + var error = Assert.Single(errorsList); + Assert.Equal(EdmErrorCode.InvalidEntitySetPath, error.ErrorCode); + Assert.Equal(Strings.CsdlParser_InvalidEntitySetPathWithUnboundAction(CsdlConstants.Element_Action, "Add"), error.ErrorMessage); } [Fact] @@ -379,8 +376,8 @@ public void ValidateActionImportReferencingNonExistingActionShouldReturnError() model.Validate(out errors); var errorsList = errors.ToList(); - errorsList.Count.Should().Be(1); - errorsList[0].ErrorCode.Should().Be(EdmErrorCode.BadUnresolvedOperation); + var error = Assert.Single(errorsList); + Assert.Equal(EdmErrorCode.BadUnresolvedOperation, error.ErrorCode); } [Fact] @@ -395,9 +392,10 @@ public void ValidateActionImportMissingActionAttributeShouldReturnError() "; + Action test = () => CsdlReader.Parse(XElement.Parse(errorDocument).CreateReader()); - test.ShouldThrow().Where(e => e.Message.Contains( - Strings.XmlParser_MissingAttribute("Action", "ActionImport"))); + var exception = Assert.Throws(test); + Assert.Contains(Strings.XmlParser_MissingAttribute("Action", "ActionImport"), exception.Message); } [Fact] @@ -407,8 +405,8 @@ public void VerifyRepresentativeModelWrittenOutCorrectly() using (var writer = XmlWriter.Create(builder)) { IEnumerable errors; - CsdlWriter.TryWriteCsdl(this.TestModel.RepresentativeModel, writer, CsdlTarget.OData, out errors).Should().BeTrue(); - errors.Should().BeEmpty(); + Assert.True(CsdlWriter.TryWriteCsdl(this.TestModel.RepresentativeModel, writer, CsdlTarget.OData, out errors)); + Assert.Empty(errors); writer.Flush(); } @@ -416,7 +414,7 @@ public void VerifyRepresentativeModelWrittenOutCorrectly() var actualXml = XElement.Parse(actual); var actualNormalized = actualXml.ToString(); - actualNormalized.Should().Be(DefaultTestModel.RepresentativeEdmxDocument); + Assert.Equal(DefaultTestModel.RepresentativeEdmxDocument, actualNormalized); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisRelationshipChangesAcceptanceTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisRelationshipChangesAcceptanceTests.cs index 3c37dea01d..9a5109cf0a 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisRelationshipChangesAcceptanceTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/ScenarioTests/OasisRelationshipChangesAcceptanceTests.cs @@ -9,7 +9,6 @@ using System.Text; using System.Xml; using System.Xml.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Validation; using Xunit; @@ -101,106 +100,107 @@ public OasisRelationshipChangesAcceptanceTests() this.entitySet2 = container.FindEntitySet("EntitySet2"); this.entityType = this.representativeModel.FindType("Test.EntityType") as IEdmEntityType; - this.entitySet1.Should().NotBeNull(); - this.entitySet2.Should().NotBeNull(); - this.entityType.Should().NotBeNull(); + Assert.NotNull(this.entitySet1); + Assert.NotNull(this.entitySet2); + Assert.NotNull(this.entityType); this.navigation1 = this.entityType.FindProperty("navigation") as IEdmNavigationProperty; this.navigation2 = this.entityType.FindProperty("NAVIGATION") as IEdmNavigationProperty; nonKeyPrincipalNavigation = this.entityType.FindProperty("NonKeyPrincipalNavigation") as IEdmNavigationProperty; var derivedType = this.representativeModel.FindType("Test.DerivedEntityType") as IEdmEntityType; - derivedType.Should().NotBeNull(); + Assert.NotNull(derivedType); this.derivedNavigation = derivedType.FindProperty("DerivedNavigation") as IEdmNavigationProperty; - this.navigation1.Should().NotBeNull(); - this.navigation2.Should().NotBeNull(); - this.derivedNavigation.Should().NotBeNull(); + Assert.NotNull(this.navigation1); + Assert.NotNull(this.navigation2); + Assert.NotNull(this.derivedNavigation); } [Fact] public void RepresentativeModelShouldBeValid() { IEnumerable errors; - this.representativeModel.Validate(out errors).Should().BeTrue(); - errors.Should().BeEmpty(); + Assert.True(this.representativeModel.Validate(out errors)); + Assert.Empty(errors); } [Fact] public void FindNavigationTargetShouldUseBinding() { - this.entitySet2.FindNavigationTarget(this.navigation2).Should().BeSameAs(this.entitySet2); - this.entitySet1.FindNavigationTarget(this.derivedNavigation).Should().BeSameAs(this.entitySet1); + Assert.Same(this.entitySet2, this.entitySet2.FindNavigationTarget(this.navigation2)); + Assert.Same(this.entitySet1, this.entitySet1.FindNavigationTarget(this.derivedNavigation)); } [Fact] public void ReferenceNavigationPropertyTypeShouldContinueToWork() { - this.navigation2.Type.Definition.Should().BeSameAs(this.entityType); + Assert.Same(this.entityType, this.navigation2.Type.Definition); } [Fact] public void CollectionNavigationPropertyTypeShouldContinueToWork() { - this.navigation1.Type.TypeKind().Should().Be(EdmTypeKind.Collection); - this.navigation1.Type.AsCollection().ElementType().Definition.Should().BeSameAs(this.entityType); + Assert.Equal(EdmTypeKind.Collection, this.navigation1.Type.TypeKind()); + Assert.Same(this.entityType, this.navigation1.Type.AsCollection().ElementType().Definition); } [Fact] public void OnDeleteShouldContinueToWork() { - this.navigation1.OnDelete.Should().Be(EdmOnDeleteAction.Cascade); - this.navigation2.OnDelete.Should().Be(EdmOnDeleteAction.None); + Assert.Equal(EdmOnDeleteAction.Cascade, this.navigation1.OnDelete); + Assert.Equal(EdmOnDeleteAction.None, this.navigation2.OnDelete); } [Fact] public void ReferentialConstraintShouldContinueToWork() { - this.navigation1.DependentProperties().Should().BeNull(); - this.navigation2.DependentProperties().Should().Contain(this.entityType.FindProperty("ForeignKeyId1") as IEdmStructuralProperty); - this.navigation2.DependentProperties().Should().Contain(this.entityType.FindProperty("ForeignKeyId2") as IEdmStructuralProperty); + Assert.Null(this.navigation1.DependentProperties()); + var properties = this.navigation2.DependentProperties(); + Assert.Contains(this.entityType.FindProperty("ForeignKeyId1") as IEdmStructuralProperty, properties); + Assert.Contains(this.entityType.FindProperty("ForeignKeyId2") as IEdmStructuralProperty, properties); } [Fact] public void ReferentialConstraintShouldWorkForNonKeyPrincipalProperties() { - this.nonKeyPrincipalNavigation.DependentProperties().Should().Contain(this.entityType.FindProperty("ForeignKeyProperty") as IEdmStructuralProperty); + Assert.Contains(this.entityType.FindProperty("ForeignKeyProperty") as IEdmStructuralProperty, this.nonKeyPrincipalNavigation.DependentProperties()); } [Fact] public void IsPrincipalShouldContinueToWork() { - this.navigation1.IsPrincipal().Should().BeTrue(); - this.navigation2.IsPrincipal().Should().BeFalse(); + Assert.True(this.navigation1.IsPrincipal()); + Assert.False(this.navigation2.IsPrincipal()); } [Fact] public void PartnerShouldContinueToWork() { - this.navigation1.Partner.Should().BeSameAs(this.navigation2); - this.navigation2.Partner.Should().BeSameAs(this.navigation1); + Assert.Same(this.navigation2, this.navigation1.Partner); + Assert.Same(this.navigation1, this.navigation2.Partner); } [Fact] public void ContainsTargetShouldContinueToWork() { - this.navigation1.ContainsTarget.Should().BeTrue(); - this.navigation2.ContainsTarget.Should().BeFalse(); + Assert.True(this.navigation1.ContainsTarget); + Assert.False(this.navigation2.ContainsTarget); } [Fact] public void NavigationTargetMappingsShouldContainAllBindings() { - this.entitySet1.NavigationPropertyBindings.Should() - .HaveCount(4) - .And.Contain(m => m.NavigationProperty == this.navigation1 && m.Target == this.entitySet1) - .And.Contain(m => m.NavigationProperty == this.navigation2 && m.Target == this.entitySet1) - .And.Contain(m => m.NavigationProperty == this.derivedNavigation && m.Target == this.entitySet1); - this.entitySet2.NavigationPropertyBindings.Should() - .HaveCount(4) - .And.Contain(m => m.NavigationProperty == this.navigation1 && m.Target == this.entitySet2) - .And.Contain(m => m.NavigationProperty == this.navigation2 && m.Target == this.entitySet2) - .And.Contain(m => m.NavigationProperty == this.derivedNavigation && m.Target == this.entitySet2); + var bindings = this.entitySet1.NavigationPropertyBindings; + Assert.Equal(4, bindings.Count()); + Assert.Contains(bindings, m => m.NavigationProperty == this.navigation1 && m.Target == this.entitySet1); + Assert.Contains(bindings, m => m.NavigationProperty == this.navigation2 && m.Target == this.entitySet1); + Assert.Contains(bindings, m => m.NavigationProperty == this.derivedNavigation && m.Target == this.entitySet1); + bindings = this.entitySet2.NavigationPropertyBindings; + Assert.Equal(4, bindings.Count()); + Assert.Contains(bindings, m => m.NavigationProperty == this.navigation1 && m.Target == this.entitySet2); + Assert.Contains(bindings, m => m.NavigationProperty == this.navigation2 && m.Target == this.entitySet2); + Assert.Contains(bindings, m => m.NavigationProperty == this.derivedNavigation && m.Target == this.entitySet2); } [Fact] @@ -210,8 +210,9 @@ public void WriterShouldContinueToWork() using (var writer = XmlWriter.Create(builder)) { IEnumerable errors; - CsdlWriter.TryWriteCsdl(this.representativeModel, writer, CsdlTarget.OData, out errors).Should().BeTrue(); - errors.Should().BeEmpty(); + var result = CsdlWriter.TryWriteCsdl(this.representativeModel, writer, CsdlTarget.OData, out errors); + Assert.True(result); + Assert.Empty(errors); writer.Flush(); } @@ -219,7 +220,7 @@ public void WriterShouldContinueToWork() var actualXml = XElement.Parse(actual); var actualNormalized = actualXml.ToString(); - actualNormalized.Should().Be(RepresentativeEdmxDocument); + Assert.Equal(RepresentativeEdmxDocument, actualNormalized); } [Fact] @@ -479,9 +480,10 @@ public void ValidationShouldFailIfEnumMemberIsSpecifiedButCannotBeFound() { IEdmModel model = GetEnumAnnotationModel(@"TestNS2.UnknownColor/Blue"); IEnumerable errors; - model.Validate(out errors).Should().BeFalse(); - errors.Should().HaveCount(1); - errors.Should().Contain(e => e.ErrorCode == EdmErrorCode.BadUnresolvedEnumMember && e.ErrorMessage == ErrorStrings.Bad_UnresolvedEnumMember("Blue")); + Assert.False(model.Validate(out errors)); + var error = Assert.Single(errors); + Assert.Equal(EdmErrorCode.BadUnresolvedEnumMember, error.ErrorCode); + Assert.Equal(ErrorStrings.Bad_UnresolvedEnumMember("Blue"), error.ErrorMessage); } [Fact] @@ -496,9 +498,9 @@ public void ValidationShouldFailIfEnumMemberIsSpecifiedButCannotBeFoundTheMember { IEdmModel model = GetEnumAnnotationModel(@"TestNS2.Color/UnknownMember"); IEnumerable errors; - model.Validate(out errors).Should().BeFalse(); - errors.Should().HaveCount(2); - errors.Should().Contain(e => e.ErrorCode == EdmErrorCode.InvalidEnumMemberPath && + Assert.False(model.Validate(out errors)); + Assert.Equal(2, errors.Count()); + Assert.Contains(errors, e => e.ErrorCode == EdmErrorCode.InvalidEnumMemberPath && e.ErrorMessage == ErrorStrings.CsdlParser_InvalidEnumMemberPath("TestNS2.Color/UnknownMember")); } @@ -507,7 +509,7 @@ public void ValidationShouldSucceedIfEnumMemberIsSpecifiedWithCorrectType() { IEdmModel model = GetEnumAnnotationModel(@"TestNS2.Color/Blue"); IEnumerable errors; - model.Validate(out errors).Should().BeTrue(); + Assert.True(model.Validate(out errors)); } private IEdmModel GetEnumAnnotationModel(string enumText) @@ -538,7 +540,7 @@ private IEdmModel GetEnumAnnotationModel(string enumText) IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeTrue(); + Assert.True(CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors)); return model; } @@ -548,13 +550,13 @@ private void ValidateBindingWithExpectedErrors(string bindingText, EdmErrorCode IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeTrue(); + Assert.True(CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors)); - model.Validate(out errors).Should().BeFalse(); - errors.Should().HaveCount(messages.Length); + Assert.False(model.Validate(out errors)); + Assert.Equal(messages.Length, errors.Count()); foreach (var message in messages) { - errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message); + Assert.Contains(errors, e => e.ErrorCode == errorCode && e.ErrorMessage == message); } } @@ -564,10 +566,10 @@ private void ValidateNavigationBindingSucceeds(string bindingText) IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeTrue(); + Assert.True(CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors)); - model.Validate(out errors).Should().BeTrue(); - errors.ToList().Count.Should().Be(0); + Assert.True(model.Validate(out errors)); + Assert.Empty(errors); } private void ValidateReferentialConstraintWithExpectedErrors(string referentialConstraintText, EdmErrorCode errorCode, params string[] messages) @@ -595,13 +597,13 @@ private void ValidateReferentialConstraintWithExpectedErrors(string referentialC IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeTrue(); + Assert.True(CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors)); - model.Validate(out errors).Should().BeFalse(); - errors.Should().HaveCount(messages.Length); + Assert.False(model.Validate(out errors)); + Assert.Equal(messages.Length, errors.Count()); foreach (var message in messages) { - errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message); + Assert.Contains(errors, e => e.ErrorCode == errorCode && e.ErrorMessage == message); } } @@ -636,24 +638,24 @@ private void ValidateNavigationWithExpectedErrors(string navigationText, EdmErro IEdmModel model; IEnumerable errors; - CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeTrue(); + Assert.True(CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors)); bool result = model.Validate(out errors); if (errorCodes.Length > 0) { - result.Should().BeFalse(); + Assert.False(result); - errors.Should().HaveCount(messages.Length); + Assert.Equal(messages.Length, errors.Count()); for (int i = 0; i < messages.Length; i++) { - errors.Should().Contain(e => e.ErrorCode == errorCodes[i] && e.ErrorMessage == messages[i]); + Assert.Contains(errors, e => e.ErrorCode == errorCodes[i] && e.ErrorMessage == messages[i]); } } else { - result.Should().BeTrue(); - errors.Should().BeEmpty(); + Assert.True(result); + Assert.Empty(errors); } } @@ -677,11 +679,11 @@ private void ParseBindingWithExpectedErrors(string bindingText, EdmErrorCode? er bool result = CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors); if (errorCode != null) { - result.Should().BeFalse(); - errors.Should().HaveCount(messages.Length); + Assert.False(result); + Assert.Equal(messages.Length, errors.Count()); foreach (var message in messages) { - errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message); + Assert.Contains(errors, e => e.ErrorCode == errorCode && e.ErrorMessage == message); } } } @@ -714,11 +716,11 @@ private void ParseReferentialConstraint(string referentialConstraintText, EdmErr bool result = CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors); if (errorCode != null) { - result.Should().BeFalse(); - errors.Should().HaveCount(messages.Length); + Assert.False(result); + Assert.Equal(messages.Length, errors.Count()); foreach (var message in messages) { - errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message); + Assert.Contains(errors, e => e.ErrorCode == errorCode && e.ErrorMessage == message); } } } @@ -730,7 +732,7 @@ private void ParseReferentialConstraintWithExpectedErrors(string referentialCons private void ParseNavigationExpectedErrors(string navigationText, EdmErrorCode[] errorCodes, string[] messages) { - errorCodes.Length.Should().Be(messages.Length); + Assert.Equal(messages.Length, errorCodes.Length); const string template = @" @@ -752,18 +754,18 @@ private void ParseNavigationExpectedErrors(string navigationText, EdmErrorCode[] bool result = CsdlReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors); if (errorCodes.Length > 0) { - result.Should().BeFalse(); + Assert.False(result); - errors.Should().HaveCount(messages.Length); + Assert.Equal(messages.Length, errors.Count()); for (int i = 0; i < messages.Length; i++) { - errors.Should().Contain(e => e.ErrorCode == errorCodes[i] && e.ErrorMessage == messages[i]); + Assert.Contains(errors, e => e.ErrorCode == errorCodes[i] && e.ErrorMessage == messages[i]); } } else { - result.Should().BeTrue(); - errors.Should().BeEmpty(); + Assert.True(result); + Assert.Empty(errors); } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationBindingTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationBindingTests.cs index 749d94a249..3592735d44 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationBindingTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationBindingTests.cs @@ -4,7 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -18,13 +17,13 @@ public void AmbigiousOperationBindingShouldReferToFirstOperationAlwaysWhenNotNul action1.AddParameter("param", EdmCoreModel.Instance.GetBoolean(false)); var function = new EdmFunction("DS2", "name2", EdmCoreModel.Instance.GetBoolean(false), true, new EdmPathExpression("path1"), true); AmbiguousOperationBinding ambigiousOperationBinding = new AmbiguousOperationBinding(action1, function); - ambigiousOperationBinding.Namespace.Should().Be("DS"); - ambigiousOperationBinding.Name.Should().Be("name"); - ambigiousOperationBinding.ReturnType.Should().BeNull(); - ambigiousOperationBinding.Parameters.Should().HaveCount(1); - ambigiousOperationBinding.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action); - ambigiousOperationBinding.IsBound.Should().BeFalse(); - ambigiousOperationBinding.EntitySetPath.Should().BeNull(); + Assert.Equal("DS", ambigiousOperationBinding.Namespace); + Assert.Equal("name", ambigiousOperationBinding.Name); + Assert.Null(ambigiousOperationBinding.ReturnType); + Assert.Single(ambigiousOperationBinding.Parameters); + Assert.Equal(EdmSchemaElementKind.Action, ambigiousOperationBinding.SchemaElementKind); + Assert.False(ambigiousOperationBinding.IsBound); + Assert.Null(ambigiousOperationBinding.EntitySetPath); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationImportBindingTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationImportBindingTests.cs index 353f44cace..1ef8f089a4 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationImportBindingTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/AmbiguousOperationImportBindingTests.cs @@ -4,8 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -20,10 +18,10 @@ public void AmbigiousOperationBindingShouldReferToFirstOperationAlwaysWhenNotNul var action1Import = new EdmActionImport(container1, "name", new EdmAction("n", "name", null)); var functionImport = new EdmFunctionImport(container2, "name", new EdmFunction("n", "name", EdmCoreModel.Instance.GetString(true))); var ambigiousOperationBinding = new AmbiguousOperationImportBinding(action1Import, functionImport); - ambigiousOperationBinding.ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); - ambigiousOperationBinding.Name.Should().Be("name"); - ambigiousOperationBinding.EntitySet.Should().BeNull(); - ambigiousOperationBinding.Container.Should().Be(container1); + Assert.Equal(EdmContainerElementKind.ActionImport, ambigiousOperationBinding.ContainerElementKind); + Assert.Equal("name", ambigiousOperationBinding.Name); + Assert.Null(ambigiousOperationBinding.EntitySet); + Assert.Same(container1, ambigiousOperationBinding.Container); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/DateAndTimeOfDayTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/DateAndTimeOfDayTests.cs index ba9fe577b0..9c61418386 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/DateAndTimeOfDayTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/DateAndTimeOfDayTests.cs @@ -7,8 +7,6 @@ using System; using System.Collections.Generic; using System.Globalization; -using FluentAssertions; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -20,7 +18,9 @@ public class DateAndTimeOfDayTests public void TestDateCtor() { Action test = () => new Date(-2013, 8, 12); - test.ShouldThrow().WithMessage(Strings.Date_InvalidDateParameters(-2013, 8, 12)); + + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidDateParameters(-2013, 8, 12), exception.Message); } [Fact] @@ -28,7 +28,7 @@ public void TestDateToDateTime() { Date date = new Date(2013, 8, 12); DateTime dt = date; - dt.Should().Be(new DateTime(2013, 8, 12)); + Assert.Equal(new DateTime(2013, 8, 12), dt); } [Fact] @@ -36,7 +36,7 @@ public void TestDateTimeToDate() { DateTime dateTime = new DateTime(2013, 8, 12); Date d = dateTime; - d.Should().Be(new Date(2013, 8, 12)); + Assert.Equal(new Date(2013, 8, 12), d); } [Fact] @@ -44,7 +44,7 @@ public void TestDateAddYears() { Date date = new Date(2013, 8, 12); Date result = date.AddYears(100); - result.Should().Be(new Date(2113, 8, 12)); + Assert.Equal(new Date(2113, 8, 12), result); } [Fact] @@ -52,7 +52,9 @@ public void TestDateAddYearsInvalidResults() { Date date = new Date(2013, 8, 12); Action test = () => date.AddYears(-5000); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] @@ -60,7 +62,8 @@ public void TestDateAddYearsInvalidParmeters() { Date date = new Date(2013, 8, 12); Action test = () => date.AddYears(12000); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] @@ -68,7 +71,7 @@ public void TesDatetAddMonths() { Date date = new Date(2013, 8, 12); Date result = date.AddMonths(1); - result.Should().Be(new Date(2013, 9, 12)); + Assert.Equal(new Date(2013, 9, 12), result); } [Fact] @@ -76,7 +79,8 @@ public void TestDateAddMonthsInvalidResults() { Date date = new Date(1, 1, 1); Action test = () => date.AddMonths(-5000); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] @@ -84,7 +88,8 @@ public void TestDateAddMonthsInvalidParmeters() { Date date = new Date(1, 1, 1); Action test = () => date.AddMonths(120001); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] @@ -92,7 +97,7 @@ public void TestDateAddDays() { Date date = new Date(2013, 8, 12); Date result = date.AddDays(1); - result.Should().Be(new Date(2013, 8, 13)); + Assert.Equal(new Date(2013, 8, 13), result); } [Fact] @@ -100,7 +105,8 @@ public void TestDateAddDaysInvalidResults() { Date date = new Date(1, 1, 1); Action test = () => date.AddDays(-2); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] @@ -108,21 +114,22 @@ public void TestDateAddDaysInvalidParmeters() { Date date = new Date(1, 1, 1); Action test = () => date.AddDays(999999999); - test.ShouldThrow().WithMessage(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value"); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidAddedOrSubtractedResults + "\r\nParameter name: value", exception.Message); } [Fact] public void TestMinDate() { Date date = Date.MinValue; - date.Should().Be(new Date(1, 1, 1)); + Assert.Equal(new Date(1, 1, 1), date); } [Fact] public void TestMaxDate() { Date date = Date.MaxValue; - date.Should().Be(new Date(9999, 12, 31)); + Assert.Equal(new Date(9999, 12, 31), date); } [Fact] @@ -130,7 +137,7 @@ public void TestNowDate() { Date date = Date.Now; DateTime dt = DateTime.Now; - date.Should().Be(new Date(dt.Year, dt.Month, dt.Day)); + Assert.Equal(new Date(dt.Year, dt.Month, dt.Day), date); } [Fact] @@ -147,7 +154,7 @@ public void TestParseDateSuccess() foreach (var tuple in lists) { Date date = Date.Parse(tuple.Item1, CultureInfo.InvariantCulture); - date.Should().Be(tuple.Item2); + Assert.Equal(tuple.Item2, date); } #endregion @@ -156,8 +163,8 @@ public void TestParseDateSuccess() { Date date; bool result = Date.TryParse(tuple.Item1, CultureInfo.InvariantCulture, out date); - result.Should().Be(true); - date.Should().Be(tuple.Item2); + Assert.True(result); + Assert.Equal(tuple.Item2, date); } #endregion } @@ -179,7 +186,8 @@ public void TestParseDateFailure() foreach (var tuple in lists) { Action test = () => Date.Parse(tuple.Item1, CultureInfo.InvariantCulture); - test.ShouldThrow().WithMessage(Strings.Date_InvalidParsingString(tuple.Item1)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidParsingString(tuple.Item1), exception.Message); } #endregion @@ -188,8 +196,8 @@ public void TestParseDateFailure() { Date date; bool result = Date.TryParse(tuple.Item1, CultureInfo.InvariantCulture, out date); - result.Should().Be(false); - date.Should().Be(tuple.Item2); + Assert.False(result); + Assert.Equal(tuple.Item2, date); } #endregion } @@ -210,7 +218,7 @@ public void TestDateEquals() foreach (var tuple in list) { bool result = tuple.Item1.Equals(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -226,7 +234,7 @@ public void TestDateEqualsObject() foreach (var tuple in list) { bool result = tuple.Item1.Equals(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -251,7 +259,7 @@ public void TestDateCompareTo() foreach (var tuple in list) { int result = tuple.Item1.CompareTo(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -261,7 +269,9 @@ public void TestDateCompareToInvalidTarget() Date date = new Date(1, 1, 1); DateTimeOffset now = DateTimeOffset.Now; Action test = () => date.CompareTo(now); - test.ShouldThrow().WithMessage(Strings.Date_InvalidCompareToTarget(now)); + + var exception = Assert.Throws(test); + Assert.Equal(Strings.Date_InvalidCompareToTarget(now), exception.Message); } [Fact] @@ -348,7 +358,8 @@ public void TestTimeOfDayCtorInvalid() foreach (var tuple in list) { Action test = () => new TimeOfDay(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4); - test.ShouldThrow().WithMessage(Strings.TimeOfDay_InvalidTimeOfDayParameters(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.TimeOfDay_InvalidTimeOfDayParameters(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4), exception.Message); } } @@ -359,7 +370,8 @@ public void TestTimeOfDayTicksCtorInvalid() foreach (var value in list) { Action test = () => new TimeOfDay(value); - test.ShouldThrow().WithMessage(Strings.TimeOfDay_TicksOutOfRange(value)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.TimeOfDay_TicksOutOfRange(value), exception.Message); } } @@ -449,7 +461,8 @@ public void TestTimeSpanToTimeOfDayException() { TimeSpan timeSpan = new TimeSpan(value); Action test = () => { TimeOfDay timeOfDay = timeSpan; }; - test.ShouldThrow().WithMessage(Strings.TimeOfDay_ConvertErrorFromTimeSpan(timeSpan)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.TimeOfDay_ConvertErrorFromTimeSpan(timeSpan), exception.Message); } } @@ -470,7 +483,7 @@ public void TestTimeOfDayEquals() foreach (var tuple in list) { bool result = tuple.Item1.Equals(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -486,7 +499,7 @@ public void TestTimeOfDayEqualsObject() foreach (var tuple in list) { bool result = tuple.Item1.Equals(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -532,7 +545,7 @@ public void TestTimeOfDayCompareTo() foreach (var tuple in list) { int result = tuple.Item1.CompareTo(tuple.Item2); - result.Should().Be(tuple.Item3); + Assert.Equal(tuple.Item3, result); } } @@ -580,7 +593,7 @@ public void TestParseTimeOfDaySuccess() foreach (var tuple in lists) { TimeOfDay time = TimeOfDay.Parse(tuple.Item1); - time.Should().Be(tuple.Item2); + Assert.Equal(tuple.Item2, time); } #endregion @@ -589,8 +602,8 @@ public void TestParseTimeOfDaySuccess() { TimeOfDay time; bool result = TimeOfDay.TryParse(tuple.Item1, out time); - result.Should().Be(true); - time.Should().Be(tuple.Item2); + Assert.True(result); + Assert.Equal(tuple.Item2, time); } #endregion } @@ -614,7 +627,8 @@ public void TestParseTimeOfDayFailure() foreach (var tuple in lists) { Action test = () => TimeOfDay.Parse(tuple.Item1); - test.ShouldThrow().WithMessage(Strings.TimeOfDay_InvalidParsingString(tuple.Item1)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.TimeOfDay_InvalidParsingString(tuple.Item1), exception.Message); } #endregion @@ -623,8 +637,8 @@ public void TestParseTimeOfDayFailure() { TimeOfDay time; bool result = TimeOfDay.TryParse(tuple.Item1, out time); - result.Should().Be(false); - time.Should().Be(tuple.Item2); + Assert.False(result); + Assert.Equal(tuple.Item2, time); } #endregion } @@ -635,7 +649,8 @@ public void TestTimeOfDayCompareToInvalidTarget() TimeOfDay time = new TimeOfDay(0); DateTimeOffset now = DateTimeOffset.Now; Action test = () => time.CompareTo(now); - test.ShouldThrow().WithMessage(Strings.TimeOfDay_InvalidCompareToTarget(now)); + var exception = Assert.Throws(test); + Assert.Equal(Strings.TimeOfDay_InvalidCompareToTarget(now), exception.Message); } [Fact] public void TestTimeOfDayOperator() diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionImportTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionImportTests.cs index fe4eaf37b9..eefc063b46 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionImportTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionImportTests.cs @@ -5,9 +5,6 @@ //--------------------------------------------------------------------- using System; -using FluentAssertions; -using Microsoft.OData.Edm; -using Microsoft.OData.Edm.Vocabularies; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -30,10 +27,10 @@ public void EdmActionImportConstructorShouldDefaultNonSpecifiedPropertiesCorrect { var edmAction = new EdmAction("DefaultNamespace", "Checkout", this.boolType); var edmActionImport = new EdmActionImport(this.entityContainer, "CheckoutImport", edmAction, null); - edmActionImport.Name.Should().Be("CheckoutImport"); - edmActionImport.EntitySet.Should().BeNull(); - edmActionImport.Container.Should().Be(this.entityContainer); - edmActionImport.Action.Should().Be(edmAction); + Assert.Equal("CheckoutImport", edmActionImport.Name); + Assert.Null(edmActionImport.EntitySet); + Assert.Same(this.entityContainer, edmActionImport.Container); + Assert.Same(edmAction, edmActionImport.Action); } [Fact] @@ -45,17 +42,17 @@ public void EdmActionImportConstructorShouldHaveSpecifiedConstructorValues() var actionImportEntitySetPath = new EdmPathExpression("Param1/Nav2"); var edmActionImport = new EdmActionImport(this.entityContainer, "checkoutImport", edmAction, actionImportEntitySetPath); - edmActionImport.Name.Should().Be("checkoutImport"); - edmActionImport.Container.Should().Be(this.entityContainer); - edmActionImport.EntitySet.Should().Be(actionImportEntitySetPath); - edmActionImport.Action.Should().Be(edmAction); + Assert.Equal("checkoutImport", edmActionImport.Name); + Assert.Same(this.entityContainer, edmActionImport.Container); + Assert.Same(actionImportEntitySetPath, edmActionImport.EntitySet); + Assert.Same(edmAction, edmActionImport.Action); } [Fact] public void EdmActionImportConstructorWithNullActionShouldThrowArgmentException() { Action test = ()=> new EdmActionImport(this.entityContainer, "checkoutImport", (IEdmAction)null, null); - test.ShouldThrow().WithMessage("Value cannot be null.\r\nParameter name: action"); + Assert.Throws("action", test); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionTests.cs index c9a0859956..9bc28e9ae9 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmActionTests.cs @@ -4,9 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; -using Microsoft.OData.Edm; -using Microsoft.OData.Edm.Vocabularies; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -28,21 +25,21 @@ public EdmActionTests() public void EdmActionConstructorWithNullReturnTypeShouldNotThrow() { var edmAction = new EdmAction(defaultNamespaceName, checkout, null); - edmAction.Namespace.Should().Be(defaultNamespaceName); - edmAction.Name.Should().Be(checkout); - edmAction.ReturnType.Should().BeNull(); + Assert.Equal(defaultNamespaceName, edmAction.Namespace); + Assert.Equal(checkout, edmAction.Name); + Assert.Null(edmAction.ReturnType); } [Fact] public void EdmActionConstructorShouldDefaultNonSpecifiedPropertiesCorrectly() { var edmAction = new EdmAction(defaultNamespaceName, checkout, this.boolType); - edmAction.Namespace.Should().Be(defaultNamespaceName); - edmAction.Name.Should().Be(checkout); - edmAction.ReturnType.Should().Be(this.boolType); - edmAction.EntitySetPath.Should().BeNull(); - edmAction.IsBound.Should().BeFalse(); - edmAction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action); + Assert.Equal(defaultNamespaceName, edmAction.Namespace); + Assert.Equal(checkout, edmAction.Name); + Assert.Same(this.boolType, edmAction.ReturnType); + Assert.Null(edmAction.EntitySetPath); + Assert.False(edmAction.IsBound); + Assert.Equal(EdmSchemaElementKind.Action, edmAction.SchemaElementKind); } [Fact] @@ -51,15 +48,15 @@ public void EdmActionConstructorShouldHaveSpecifiedConstructorValues() var entitySetPath = new EdmPathExpression("Param1/Nav"); var edmAction = new EdmAction(defaultNamespaceName, checkout, this.boolType, true, entitySetPath); edmAction.AddParameter(new EdmOperationParameter(edmAction, "Param1", new EdmEntityTypeReference(personType, false))); - edmAction.Namespace.Should().Be(defaultNamespaceName); - edmAction.Name.Should().Be(checkout); - edmAction.ReturnType.Should().Be(this.boolType); - edmAction.EntitySetPath.Should().Be(entitySetPath); - edmAction.IsBound.Should().BeTrue(); - edmAction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action); + Assert.Equal(defaultNamespaceName, edmAction.Namespace); + Assert.Equal(checkout, edmAction.Name); + Assert.Same(this.boolType, edmAction.ReturnType); + Assert.Same(entitySetPath, edmAction.EntitySetPath); + Assert.True(edmAction.IsBound); + Assert.Equal(EdmSchemaElementKind.Action, edmAction.SchemaElementKind); - edmAction.Return.Should().NotBeNull(); - edmAction.Return.Type.Should().BeSameAs(edmAction.ReturnType); + Assert.NotNull(edmAction.Return); + Assert.Same(edmAction.ReturnType, edmAction.Return.Type); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmEntityContainerTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmEntityContainerTests.cs index 3699bb4892..a97cbfc7fe 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmEntityContainerTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmEntityContainerTests.cs @@ -5,7 +5,6 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -29,9 +28,9 @@ public void EnsureActionImportIsAddedWithActionSuppliedName() EdmAction action = new EdmAction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false)); var actionImport = container.AddActionImport(action); - actionImport.Action.Should().Be(action); - actionImport.Name.Should().Be(action.Name); - container.Elements.ToArray()[0].Should().Be(actionImport); + Assert.Same(action, actionImport.Action); + Assert.Equal(action.Name, actionImport.Name); + Assert.Same(actionImport, container.Elements.ToArray()[0]); } [Fact] @@ -41,9 +40,9 @@ public void EnsureActionImportIsAddedAndWithCorrectSuppliedName() EdmAction action = new EdmAction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false)); var actionImport = container.AddActionImport("OtherName", action); - actionImport.Action.Should().Be(action); - actionImport.Name.Should().Be("OtherName"); - container.Elements.ToArray()[0].Should().Be(actionImport); + Assert.Same(action, actionImport.Action); + Assert.Equal("OtherName", actionImport.Name); + Assert.Same(actionImport, container.Elements.ToArray()[0]); } [Fact] @@ -54,10 +53,10 @@ public void EnsureActionImportIsAddedAndWithCorrectEntitySetExpression() var entitySetExpression = new EdmPathExpression("EntitySet"); var actionImport = container.AddActionImport("OtherName", action, entitySetExpression); - actionImport.Action.Should().Be(action); - actionImport.Name.Should().Be("OtherName"); - actionImport.EntitySet.Should().Be(entitySetExpression); - container.Elements.ToArray()[0].Should().Be(actionImport); + Assert.Same(action, actionImport.Action); + Assert.Equal("OtherName", actionImport.Name); + Assert.Same(entitySetExpression, actionImport.EntitySet); + Assert.Same(actionImport, container.Elements.ToArray()[0]); } #endregion @@ -69,9 +68,9 @@ public void EnsureFunctionImportIsAddedWithActionSuppliedName() EdmFunction function = new EdmFunction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false)); var functionImport = container.AddFunctionImport(function); - functionImport.Function.Should().Be(function); - functionImport.Name.Should().Be(function.Name); - container.Elements.ToArray()[0].Should().Be(functionImport); + Assert.Same(function, functionImport.Function); + Assert.Equal(function.Name, functionImport.Name); + Assert.Same(functionImport, container.Elements.ToArray()[0]); } [Fact] @@ -81,9 +80,9 @@ public void EnsureFunctionImportIsAddedAndWithCorrectSuppliedName() EdmFunction function = new EdmFunction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false)); var functionImport = container.AddFunctionImport("OtherName", function); - functionImport.Function.Should().Be(function); - functionImport.Name.Should().Be("OtherName"); - container.Elements.ToArray()[0].Should().Be(functionImport); + Assert.Same(function, functionImport.Function); + Assert.Equal("OtherName", functionImport.Name); + Assert.Same(functionImport, container.Elements.ToArray()[0]); } [Fact] @@ -92,12 +91,12 @@ public void EnsureFunctionImportIsAddedAndWithCorrectEntitySetExpression() EdmEntityContainer container = new EdmEntityContainer("Default", "Container"); EdmAction action = new EdmAction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false)); var entitySetExpression = new EdmPathExpression("EntitySet"); - var functionImport = container.AddActionImport("OtherName", action, entitySetExpression); + var actionImport = container.AddActionImport("OtherName", action, entitySetExpression); - functionImport.Action.Should().Be(action); - functionImport.Name.Should().Be("OtherName"); - functionImport.EntitySet.Should().Be(entitySetExpression); - container.Elements.ToArray()[0].Should().Be(functionImport); + Assert.Same(action, actionImport.Action); + Assert.Equal("OtherName", actionImport.Name); + Assert.Same(entitySetExpression, actionImport.EntitySet); + Assert.Same(actionImport, container.Elements.ToArray()[0]); } #endregion } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmFunctionTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmFunctionTests.cs index 5cad4452c8..aa3ffb7969 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmFunctionTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmFunctionTests.cs @@ -5,9 +5,6 @@ //--------------------------------------------------------------------- using System; -using FluentAssertions; -using Microsoft.OData.Edm; -using Microsoft.OData.Edm.Vocabularies; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -29,30 +26,30 @@ public EdmFunctionTests() public void EdmFunctionShouldThrowIfReturnTypeIsNull() { Action test = () => new EdmFunction(defaultNamespaceName, checkout, null); - test.ShouldThrow(); + Assert.Throws("returnType", test); } [Fact] public void EdmFunctionConstructorWithNullReturnTypeShouldNotThrow() { var edmFunction = new EdmFunction(defaultNamespaceName, checkout, this.boolType); - edmFunction.Namespace.Should().Be(defaultNamespaceName); - edmFunction.Name.Should().Be(checkout); - edmFunction.ReturnType.Should().Be(this.boolType); - edmFunction.IsComposable.Should().BeFalse(); + Assert.Equal(defaultNamespaceName, edmFunction.Namespace); + Assert.Equal(checkout, edmFunction.Name); + Assert.Same(this.boolType, edmFunction.ReturnType); + Assert.False(edmFunction.IsComposable); } [Fact] public void EdmFunctionConstructorShouldDefaultNonSpecifiedPropertiesCorrectly() { var edmFunction = new EdmFunction(defaultNamespaceName, checkout, this.boolType); - edmFunction.Namespace.Should().Be(defaultNamespaceName); - edmFunction.Name.Should().Be(checkout); - edmFunction.ReturnType.Should().Be(this.boolType); - edmFunction.EntitySetPath.Should().BeNull(); - edmFunction.IsBound.Should().BeFalse(); - edmFunction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Function); - edmFunction.IsComposable.Should().BeFalse(); + Assert.Equal(defaultNamespaceName, edmFunction.Namespace); + Assert.Equal(checkout, edmFunction.Name); + Assert.Same(this.boolType, edmFunction.ReturnType); + Assert.Null(edmFunction.EntitySetPath); + Assert.False(edmFunction.IsBound); + Assert.Equal(EdmSchemaElementKind.Function, edmFunction.SchemaElementKind); + Assert.False(edmFunction.IsComposable); } [Fact] @@ -61,16 +58,16 @@ public void EdmFunctionConstructorShouldHaveSpecifiedConstructorValues() var entitySetPath = new EdmPathExpression("Param1/Nav"); var edmFunction = new EdmFunction(defaultNamespaceName, checkout, this.boolType, true, entitySetPath, true /*IsComposable*/); edmFunction.AddParameter(new EdmOperationParameter(edmFunction, "Param1", new EdmEntityTypeReference(personType, false))); - edmFunction.Namespace.Should().Be(defaultNamespaceName); - edmFunction.Name.Should().Be(checkout); - edmFunction.ReturnType.Should().Be(this.boolType); - edmFunction.EntitySetPath.Should().Be(entitySetPath); - edmFunction.IsBound.Should().BeTrue(); - edmFunction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Function); - edmFunction.IsComposable.Should().BeTrue(); + Assert.Equal(defaultNamespaceName, edmFunction.Namespace); + Assert.Equal(checkout, edmFunction.Name); + Assert.Same(this.boolType, edmFunction.ReturnType); + Assert.Same(entitySetPath, edmFunction.EntitySetPath); + Assert.True(edmFunction.IsBound); + Assert.Equal(EdmSchemaElementKind.Function, edmFunction.SchemaElementKind); + Assert.True(edmFunction.IsComposable); - edmFunction.Return.Should().NotBeNull(); - edmFunction.Return.Type.Should().BeSameAs(edmFunction.ReturnType); + Assert.NotNull(edmFunction.Return); + Assert.Same(edmFunction.ReturnType, edmFunction.Return.Type); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmModelBaseTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmModelBaseTests.cs index 1892de628b..203bca8f77 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmModelBaseTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmModelBaseTests.cs @@ -6,8 +6,6 @@ using System.Collections.Generic; using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Vocabularies; using Xunit; @@ -24,8 +22,8 @@ public void FindDeclaredOperationsShouldFindFullyQualifiedName() model.Add(new EdmAction("n", "a2", null)); var findResults = model.FindDeclaredOperations("n.a").ToList(); - findResults.Should().HaveCount(1); - findResults[0].Name.Should().Be("a"); + var result = Assert.Single(findResults); + Assert.Equal("a", result.Name); } [Fact] @@ -36,7 +34,7 @@ public void FindDeclaredOperationsShouldFindAllActionsWithSameNameAndDifferentNa model.Add(new EdmAction("n2", "a", null)); var findResults = model.FindDeclaredOperations("a").ToList(); - findResults.Should().HaveCount(0); + Assert.Empty(findResults); } [Fact] @@ -46,7 +44,8 @@ public void FindDeclaredOperationsShouldFindAllActionsShouldNotFindUnknownAction model.Add(new EdmAction("n", "a", null)); model.Add(new EdmAction("n2", "a", null)); - var findResults = model.FindDeclaredOperations("a2").Should().HaveCount(0); + var findResults = model.FindDeclaredOperations("a2"); + Assert.Empty(findResults); } [Fact] @@ -56,7 +55,8 @@ public void FindDeclaredOperationsShouldFindAllActionsShouldNotFindUnknownAction model.Add(new EdmAction("n", "a", null)); model.Add(new EdmAction("n2", "a", null)); - var findResults = model.FindDeclaredOperations("n.a2").Should().HaveCount(0); + var findResults = model.FindDeclaredOperations("n.a2"); + Assert.Empty(findResults); } #endregion diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmReferentialConstraintTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmReferentialConstraintTests.cs index ac8a3a8b55..9fe0cc25c4 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmReferentialConstraintTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmReferentialConstraintTests.cs @@ -6,8 +6,6 @@ using System; using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -44,68 +42,75 @@ public EdmReferentialConstraintTests() public void CreateReferentialConstraintShouldSucceedForSinglePropertyKey() { var testSubject = EdmReferentialConstraint.Create(new[] {this.otherTypeProperty1}, this.typeWithOneKey.Key()); - testSubject.PropertyPairs.Should().HaveCount(1) - .And.Contain(p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == this.key1_1); + var pair = Assert.Single(testSubject.PropertyPairs); + Assert.Same(this.otherTypeProperty1, pair.DependentProperty); + Assert.Same(this.key1_1, pair.PrincipalProperty); } [Fact] public void CreateReferentialConstraintShouldSucceedForTwoPropertyKey() { var testSubject = EdmReferentialConstraint.Create(new[] {this.otherTypeProperty1, this.otherTypeProperty2}, this.typeWithTwoKeys.Key()); - testSubject.PropertyPairs.Should().HaveCount(2) - .And.Contain(p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == this.key2_1) - .And.Contain(p => p.DependentProperty == this.otherTypeProperty2 && p.PrincipalProperty == this.key2_2); + Assert.Equal(2, testSubject.PropertyPairs.Count()); + + Assert.Contains(testSubject.PropertyPairs, p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == this.key2_1); + Assert.Contains(testSubject.PropertyPairs, p => p.DependentProperty == this.otherTypeProperty2 && p.PrincipalProperty == this.key2_2); } [Fact] public void CreateReferentialConstraintShouldSucceedForNonKeyPrincipalProperty() { var testSubject = EdmReferentialConstraint.Create(new[] { this.otherTypeProperty1 }, new []{ this.property1 }); - testSubject.PropertyPairs.Should().HaveCount(1).And.Contain(p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == property1); + var pair = Assert.Single(testSubject.PropertyPairs); + Assert.Same(this.otherTypeProperty1, pair.DependentProperty); + Assert.Same(this.property1, pair.PrincipalProperty); } [Fact] public void CreateReferentialConstraintShouldNotChangeOrderOfProperties() { var testSubject = EdmReferentialConstraint.Create(new[] {this.otherTypeProperty2, this.otherTypeProperty1}, this.typeWithTwoKeys.Key()); - testSubject.PropertyPairs.Should().HaveCount(2) - .And.Contain(p => p.DependentProperty == this.otherTypeProperty2 && p.PrincipalProperty == this.key2_1) - .And.Contain(p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == this.key2_2); + Assert.Equal(2, testSubject.PropertyPairs.Count()); + Assert.Contains(testSubject.PropertyPairs, p => p.DependentProperty == this.otherTypeProperty2 && p.PrincipalProperty == this.key2_1); + Assert.Contains(testSubject.PropertyPairs, p => p.DependentProperty == this.otherTypeProperty1 && p.PrincipalProperty == this.key2_2); } [Fact] public void CreateReferentialConstraintShouldFailIfTooFewPropertiesAreGiven() { Action createWithTooFewProperties = () => EdmReferentialConstraint.Create(new[] { this.otherTypeProperty1 }, this.typeWithTwoKeys.Key()); - createWithTooFewProperties.ShouldThrow().WithMessage(Strings.Constructable_DependentPropertyCountMustMatchNumberOfPropertiesOnPrincipalType(2, 1)); + + var exception = Assert.Throws(createWithTooFewProperties); + Assert.Equal(Strings.Constructable_DependentPropertyCountMustMatchNumberOfPropertiesOnPrincipalType(2, 1), exception.Message); } [Fact] public void CreateReferentialConstraintShouldFailIfTooManyPropertiesAreGiven() { Action createWithTooManyProperties = () => EdmReferentialConstraint.Create(new[] { this.otherTypeProperty1, this.otherTypeProperty2 }, this.typeWithOneKey.Key()); - createWithTooManyProperties.ShouldThrow().WithMessage(Strings.Constructable_DependentPropertyCountMustMatchNumberOfPropertiesOnPrincipalType(1, 2)); + var exception = Assert.Throws(createWithTooManyProperties); + Assert.Equal(Strings.Constructable_DependentPropertyCountMustMatchNumberOfPropertiesOnPrincipalType(1, 2), exception.Message); } [Fact] public void CreateReferentialConstraintShouldFailIfPropertiesAreNull() { Action createWithNullProperties = () => EdmReferentialConstraint.Create(null, this.typeWithOneKey.Key()); - createWithNullProperties.ShouldThrow().Where(e => e.Message.Contains("dependentProperties")); + Assert.Throws("dependentProperties", createWithNullProperties); } [Fact] public void CreateReferentialConstraintShouldFailIfPrincipalPropertiesAreNull() { Action createWithNullProperties = () => EdmReferentialConstraint.Create(Enumerable.Empty(), null); - createWithNullProperties.ShouldThrow().Where(e => e.Message.Contains("principalProperties")); + Assert.Throws("principalProperties", createWithNullProperties); } [Fact] public void ReferentialConstraintConstructorShouldFailIfPairsAreNull() { Action constructWithNullPairs = () => new EdmReferentialConstraint(null); - constructWithNullPairs.ShouldThrow().Where(e => e.Message.Contains("propertyPairs")); + Assert.Throws("propertyPairs", constructWithNullPairs); } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmSingletonTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmSingletonTests.cs index 333c24edfb..eeb13a5507 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmSingletonTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmSingletonTests.cs @@ -5,8 +5,6 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Vocabularies; using Xunit; @@ -32,9 +30,9 @@ public EdmSingletonTests() public void EdmSingletonBasicAttributeTest() { EdmSingleton singleton = new EdmSingleton(this.entityContainer, "VIP", customerType); - singleton.Container.Should().Be(this.entityContainer); - singleton.ContainerElementKind.Should().Be(EdmContainerElementKind.Singleton); - singleton.EntityType().Should().Be(customerType); + Assert.Same(this.entityContainer, singleton.Container); + Assert.Equal(EdmContainerElementKind.Singleton, singleton.ContainerElementKind); + Assert.Same(customerType, singleton.EntityType()); } [Fact] @@ -52,23 +50,23 @@ public void EdmSingletonBasicNavigationPropertyBindingTest() var vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType); - vipCustomer.NavigationPropertyBindings.Should().HaveCount(0); + Assert.Empty(vipCustomer.NavigationPropertyBindings); vipCustomer.AddNavigationTarget(internalOrderProperty, orderSet); vipCustomer.AddNavigationTarget(externalOrderProperty, orderSet); vipCustomer.AddNavigationTarget(customerProductProperty, productSet); - vipCustomer.NavigationPropertyBindings.Should().HaveCount(3) - .And.Contain(m => m.NavigationProperty == internalOrderProperty && m.Target == orderSet) - .And.Contain(m => m.NavigationProperty == externalOrderProperty && m.Target == orderSet) - .And.Contain(m=>m.NavigationProperty == customerProductProperty && m.Target == productSet); + Assert.Equal(3, vipCustomer.NavigationPropertyBindings.Count()); + Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == internalOrderProperty && m.Target == orderSet); + Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == externalOrderProperty && m.Target == orderSet); + Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == customerProductProperty && m.Target == productSet); - vipCustomer.FindNavigationTarget(internalOrderProperty).Should().Be(orderSet); - vipCustomer.FindNavigationTarget(externalOrderProperty).Should().Be(orderSet); - vipCustomer.FindNavigationTarget(customerProductProperty).Should().Be(productSet); + Assert.Same(orderSet, vipCustomer.FindNavigationTarget(internalOrderProperty)); + Assert.Same(orderSet, vipCustomer.FindNavigationTarget(externalOrderProperty)); + Assert.Same(productSet, vipCustomer.FindNavigationTarget(customerProductProperty)); productSet.AddNavigationTarget(customerProductProperty.Partner, vipCustomer); - productSet.FindNavigationTarget(customerProductProperty.Partner).Should().Be(vipCustomer); + Assert.Same(vipCustomer, productSet.FindNavigationTarget(customerProductProperty.Partner)); } [Fact] @@ -154,29 +152,29 @@ public void EdmSingletonAdvancedContainedNavigationPropertyBindingTest() s.AddNavigationTarget(btocNavProp, sa2bda1bc, new EdmPathExpression("a2/b/TestNS.dType/a1/b/c")); var foundSc = s.FindNavigationTarget(stocNavProp); - foundSc.Should().Be(sc); + Assert.Same(sc, foundSc); var foundSb = s.FindNavigationTarget(stobNavProp); Assert.True(foundSb is IEdmContainedEntitySet); var foundSbc = foundSb.FindNavigationTarget(btocNavProp); - foundSbc.Should().Be(sbc); + Assert.Same(sbc, foundSbc); var foundSa1 = s.FindNavigationTarget(stoa1NavProp); Assert.True(foundSa1 is IEdmContainedEntitySet); var foundSa1b = foundSa1.FindNavigationTarget(atobNavProp); Assert.True(foundSa1b is IEdmContainedEntitySet); var foundSa1bc = foundSa1b.FindNavigationTarget(btocNavProp); - foundSa1bc.Should().Be(sa1bc); + Assert.Same(sa1bc, foundSa1bc); var foundSa2 = s.FindNavigationTarget(stoa2NavProp); Assert.True(foundSa2 is IEdmContainedEntitySet); var foundSa2b = foundSa2.FindNavigationTarget(atobNavProp); Assert.True(foundSa2b is IEdmContainedEntitySet); var foundSa2bc = foundSa2b.FindNavigationTarget(btocNavProp); - foundSa2bc.Should().Be(sa2bc); + Assert.Same(sa2bc, foundSa2bc); var foundSa2bda1 = foundSa2b.FindNavigationTarget(dtoa1NavProp, new EdmPathExpression("TestNS.dType/a1")); Assert.True(foundSa2bda1 is IEdmContainedEntitySet); var foundSa2bda1b = foundSa2bda1.FindNavigationTarget(atobNavProp); Assert.True(foundSa2bda1b is IEdmContainedEntitySet); var foundSa2bda1bc = foundSa2bda1b.FindNavigationTarget(btocNavProp); - foundSa2bda1bc.Should().Be(sa2bda1bc); + Assert.Same(sa2bda1bc, foundSa2bda1bc); } [Fact] diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmTypeDefinitionTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmTypeDefinitionTests.cs index 95991bec89..f1e46ba25a 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmTypeDefinitionTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Schema/EdmTypeDefinitionTests.cs @@ -4,8 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; -using Microsoft.OData.Edm; using Xunit; namespace Microsoft.OData.Edm.Tests.Library @@ -71,13 +69,13 @@ public void TestModelWithTypeDefinition() var addressTypeReference = new EdmTypeDefinitionReference(addressType, false); personType.AddStructuralProperty("Address", addressTypeReference); - addressTypeReference.Definition.Should().Be(addressType); - addressTypeReference.IsNullable.Should().BeFalse(); + Assert.Same(addressType, addressTypeReference.Definition); + Assert.False(addressTypeReference.IsNullable); var weightTypeReference = new EdmTypeDefinitionReference(weightType, true); personType.AddStructuralProperty("Weight", weightTypeReference); - weightTypeReference.Definition.Should().Be(weightType); - weightTypeReference.IsNullable.Should().BeTrue(); + Assert.Same(weightType, weightTypeReference.Definition); + Assert.True(weightTypeReference.IsNullable); var personId = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32); personType.AddKeys(personId); @@ -87,64 +85,64 @@ public void TestModelWithTypeDefinition() public void TestEdmTypeDefinitionConstructorWithPrimitiveTypeKind() { var intAlias = new EdmTypeDefinition("MyNS", "TestInt", EdmPrimitiveTypeKind.Int32); - intAlias.Namespace.Should().Be("MyNS"); - intAlias.Name.Should().Be("TestInt"); - intAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - intAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - intAlias.UnderlyingType.PrimitiveKind.Should().Be(EdmPrimitiveTypeKind.Int32); + Assert.Equal("MyNS", intAlias.Namespace); + Assert.Equal("TestInt", intAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, intAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, intAlias.SchemaElementKind); + Assert.Equal(EdmPrimitiveTypeKind.Int32, intAlias.UnderlyingType.PrimitiveKind); var stringAlias = new EdmTypeDefinition("MyNamespace", "TestString", EdmPrimitiveTypeKind.String); - stringAlias.Namespace.Should().Be("MyNamespace"); - stringAlias.Name.Should().Be("TestString"); - stringAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - stringAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - stringAlias.UnderlyingType.PrimitiveKind.Should().Be(EdmPrimitiveTypeKind.String); + Assert.Equal("MyNamespace", stringAlias.Namespace); + Assert.Equal("TestString", stringAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, stringAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, stringAlias.SchemaElementKind); + Assert.Equal(EdmPrimitiveTypeKind.String, stringAlias.UnderlyingType.PrimitiveKind); var decimalAlias = new EdmTypeDefinition("TestNS", "TestDecimal", EdmPrimitiveTypeKind.Decimal); - decimalAlias.Namespace.Should().Be("TestNS"); - decimalAlias.Name.Should().Be("TestDecimal"); - decimalAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - decimalAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - decimalAlias.UnderlyingType.PrimitiveKind.Should().Be(EdmPrimitiveTypeKind.Decimal); + Assert.Equal("TestNS", decimalAlias.Namespace); + Assert.Equal("TestDecimal", decimalAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, decimalAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, decimalAlias.SchemaElementKind); + Assert.Equal(EdmPrimitiveTypeKind.Decimal, decimalAlias.UnderlyingType.PrimitiveKind); var booleanAlias = new EdmTypeDefinition("TestNamespace", "TestBoolean", EdmPrimitiveTypeKind.Boolean); - booleanAlias.Namespace.Should().Be("TestNamespace"); - booleanAlias.Name.Should().Be("TestBoolean"); - booleanAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - booleanAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - booleanAlias.UnderlyingType.PrimitiveKind.Should().Be(EdmPrimitiveTypeKind.Boolean); + Assert.Equal("TestNamespace", booleanAlias.Namespace); + Assert.Equal("TestBoolean", booleanAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, booleanAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, booleanAlias.SchemaElementKind); + Assert.Equal(EdmPrimitiveTypeKind.Boolean, booleanAlias.UnderlyingType.PrimitiveKind); } [Fact] public void TestEdmTypeDefinitionConstructorWithPrimitiveType() { var intAlias = new EdmTypeDefinition("MyNS", "TestInt", EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32)); - intAlias.Namespace.Should().Be("MyNS"); - intAlias.Name.Should().Be("TestInt"); - intAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - intAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - intAlias.UnderlyingType.Should().Be(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32)); + Assert.Equal("MyNS", intAlias.Namespace); + Assert.Equal("TestInt", intAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, intAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, intAlias.SchemaElementKind); + Assert.Equal(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32), intAlias.UnderlyingType); var stringAlias = new EdmTypeDefinition("MyNamespace", "TestString", EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String)); - stringAlias.Namespace.Should().Be("MyNamespace"); - stringAlias.Name.Should().Be("TestString"); - stringAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - stringAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - stringAlias.UnderlyingType.Should().Be(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String)); + Assert.Equal("MyNamespace", stringAlias.Namespace); + Assert.Equal("TestString", stringAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, stringAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, stringAlias.SchemaElementKind); + Assert.Same(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), stringAlias.UnderlyingType); var decimalAlias = new EdmTypeDefinition("TestNS", "TestDecimal", EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal)); - decimalAlias.Namespace.Should().Be("TestNS"); - decimalAlias.Name.Should().Be("TestDecimal"); - decimalAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - decimalAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - decimalAlias.UnderlyingType.Should().Be(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal)); + Assert.Equal("TestNS", decimalAlias.Namespace); + Assert.Equal("TestDecimal", decimalAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, decimalAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, decimalAlias.SchemaElementKind); + Assert.Same(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal), decimalAlias.UnderlyingType); var booleanAlias = new EdmTypeDefinition("TestNamespace", "TestBoolean", EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Boolean)); - booleanAlias.Namespace.Should().Be("TestNamespace"); - booleanAlias.Name.Should().Be("TestBoolean"); - booleanAlias.TypeKind.Should().Be(EdmTypeKind.TypeDefinition); - booleanAlias.SchemaElementKind.Should().Be(EdmSchemaElementKind.TypeDefinition); - booleanAlias.UnderlyingType.Should().Be(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Boolean)); + Assert.Equal("TestNamespace", booleanAlias.Namespace); + Assert.Equal("TestBoolean", booleanAlias.Name); + Assert.Equal(EdmTypeKind.TypeDefinition, booleanAlias.TypeKind); + Assert.Equal(EdmSchemaElementKind.TypeDefinition, booleanAlias.SchemaElementKind); + Assert.Same(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Boolean), booleanAlias.UnderlyingType); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/DuplicateOperationValidatorTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/DuplicateOperationValidatorTests.cs index 7763483912..11c31672f4 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/DuplicateOperationValidatorTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/DuplicateOperationValidatorTests.cs @@ -5,8 +5,6 @@ //--------------------------------------------------------------------- using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Validation; using Xunit; @@ -333,7 +331,7 @@ private static void ValidateNoError(IEdmModel model) var context = ExecuteDuplicateOperationValidator(model); var errors = context.Errors.ToList(); - errors.Should().HaveCount(0); + Assert.Empty(errors); } private static ValidationContext ExecuteDuplicateOperationValidator(IEdmModel model) @@ -351,9 +349,9 @@ private static void ValidateError(IEdmModel model, EdmErrorCode expectedErrorCod { var context = ExecuteDuplicateOperationValidator(model); var errors = context.Errors.ToList(); - errors.Should().HaveCount(1); - errors[0].ErrorCode.Should().Be(expectedErrorCode); - errors[0].ErrorMessage.Should().Be(expectedError); + Assert.Single(errors); + Assert.Equal(expectedErrorCode, errors[0].ErrorCode); + Assert.Equal(expectedError, errors[0].ErrorMessage); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/Internal/ValidationHelperTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/Internal/ValidationHelperTests.cs index 0d50d5e74d..eb02b6daee 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/Internal/ValidationHelperTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/Internal/ValidationHelperTests.cs @@ -4,7 +4,6 @@ // //--------------------------------------------------------------------- -using FluentAssertions; using Microsoft.OData.Edm; using Microsoft.OData.Edm.Validation; using Microsoft.OData.Edm.Vocabularies; @@ -29,7 +28,7 @@ public void EnsureDuplicateEntityTypeAndFunctionReturnTrue() model.AddElement(edmFunction); model.AddReferencedModel(otherModel); - model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName()).Should().BeTrue(); + Assert.True(model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName())); } [Fact] @@ -44,7 +43,7 @@ public void EnsureDuplicateTermAndFunctionReturnTrue() otherModel.AddElement(edmTerm); model.AddReferencedModel(otherModel); - model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName()).Should().BeTrue(); + Assert.True(model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName())); } [Fact] @@ -59,7 +58,7 @@ public void EnsureDuplicateContainerFunctionReturnTrue() otherModel.AddElement(container); model.AddReferencedModel(otherModel); - model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName()).Should().BeTrue(); + Assert.True(model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName())); } [Fact] @@ -74,7 +73,7 @@ public void EnsureNoDuplicateFoundForFunctionShouldReturnFalse() model.AddElement(edmFunction); model.AddReferencedModel(otherModel); - model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName()).Should().BeFalse(); + Assert.False(model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName())); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRuleSetTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRuleSetTests.cs index 2ce0d971b6..3b22d3a280 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRuleSetTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRuleSetTests.cs @@ -7,7 +7,6 @@ using System; using System.Collections.Generic; using System.Linq; -using FluentAssertions; using Microsoft.OData.Edm.Validation; using Xunit; @@ -46,8 +45,8 @@ public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules( } } - unFoundValidationRules.Should().HaveCount(0); - validationRules.ToList().Should().HaveCount(0); + Assert.Empty(unFoundValidationRules); + Assert.Empty(validationRules); } } } diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRulesTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRulesTests.cs index 4369280976..c2c260e810 100644 --- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRulesTests.cs +++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Validation/ValidationRulesTests.cs @@ -8,8 +8,6 @@ using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; -using FluentAssertions; -using Microsoft.OData.Edm; using Microsoft.OData.Edm.Csdl; using Microsoft.OData.Edm.Validation; using Microsoft.OData.Edm.Vocabularies; @@ -360,7 +358,7 @@ public void OperationImportEntitySetReferencesBadEntityShouldNotError() ValidationRules.OperationImportEntitySetExpressionIsInvalid.Evaluate(context, edmFunctionImport); var errors = context.Errors.ToList(); - errors.Should().HaveCount(0); + Assert.Empty(errors); } #endregion @@ -1426,7 +1424,7 @@ private static void ValidateNoError(ValidationRule validationRule, IEdmMod ValidationContext context = new ValidationContext(model, (object o) => false); validationRule.Evaluate(context, item); var errors = context.Errors.ToList(); - errors.Should().HaveCount(0); + Assert.Empty(errors); } private static void ValidateError(ValidationRule validationRule, IEdmModel model, T item, EdmErrorCode expectedErrorCode, string expectedError) where T : IEdmElement @@ -1434,9 +1432,9 @@ private static void ValidateError(ValidationRule validationRule, IEdmModel ValidationContext context = new ValidationContext(model, (object o) => false); validationRule.Evaluate(context, item); var errors = context.Errors.ToList(); - errors.Should().HaveCount(1); - errors[0].ErrorCode.Should().Be(expectedErrorCode); - errors[0].ErrorMessage.Should().Be(expectedError); + var error = Assert.Single(errors); + Assert.Equal(expectedErrorCode, error.ErrorCode); + Assert.Equal(expectedError, error.ErrorMessage); } private static void ValidateExactErrorsInList(ValidationRule validationRule, IEdmModel model, T item, params Tuple [] expectedErrors) where T : IEdmElement @@ -1446,12 +1444,12 @@ private static void ValidateExactErrorsInList(ValidationRule validationRul int currentIndex = 0; foreach(var actualError in context.Errors) { - actualError.ErrorCode.Should().Be(expectedErrors[currentIndex].Item1); - actualError.ErrorMessage.Should().Be(expectedErrors[currentIndex].Item2); + Assert.Equal(expectedErrors[currentIndex].Item1, actualError.ErrorCode); + Assert.Equal(expectedErrors[currentIndex].Item2, actualError.ErrorMessage); currentIndex++; } - context.Errors.ToList().Count.Should().Be(expectedErrors.Length); + Assert.Equal(expectedErrors.Length, context.Errors.ToList().Count); } private static void ValidateErrorInList(ValidationRule validationRule, IEdmModel model, T item, EdmErrorCode expectedErrorCode, string expectedError) where T : IEdmElement @@ -1459,8 +1457,8 @@ private static void ValidateErrorInList(ValidationRule validationRule, IEd ValidationContext context = new ValidationContext(model, (object o) => false); validationRule.Evaluate(context, item); var error = context.Errors.SingleOrDefault(e=>e.ErrorCode == expectedErrorCode); - error.Should().NotBeNull(); - error.ErrorMessage.Should().Be(expectedError); + Assert.NotNull(error); + Assert.Equal(expectedError, error.ErrorMessage); } private static void ValidateError(ValidationRule validationRule, T item, EdmErrorCode expectedErrorCode, string expectedError) where T:IEdmElement