public void SetupThrowsWhenSubstituteIsNull()
        {
            // Arrange
            var context = Substitute.For <ISpecimenContext>();
            var sut     = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(null, context));
        }
 public void SetupThrowsWhenContextIsNull()
 {
     // Fixture setup
     var substitute = Substitute.For<object>();
     var sut = new NSubstituteSealedPropertiesCommand();
     // Exercise system and verify outcome
     Assert.Throws<ArgumentNullException>(
         () => sut.Execute(substitute, null));
     // Teardown
 }
        public void SetupThrowsWhenContextIsNull()
        {
            // Arrange
            var substitute = Substitute.For <object>();
            var sut        = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(substitute, null));
        }
        public void SetupThrowsWhenContextIsNull()
        {
            // Fixture setup
            var substitute = Substitute.For <object>();
            var sut        = new NSubstituteSealedPropertiesCommand();

            // Exercise system and verify outcome
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(substitute, null));
            // Teardown
        }
        public void IgnoresGetOnlyProperties()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenString = fixture.Freeze<string>();
            var substitute = Substitute.For<TypeWithGetOnlyProperty>();
            var sut = new NSubstituteSealedPropertiesCommand();
            //Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenString, substitute.GetOnlyProperty);
        }
        public void IgnoresNonSubstituteSpecimens()
        {
            // Fixture setup
            var context  = Substitute.For <ISpecimenContext>();
            var specimen = new ConcreteTypeWithSealedMembers();
            var sut      = new NSubstituteSealedPropertiesCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(specimen, context));

            context.DidNotReceiveWithAnyArgs().Resolve(null);
        }
        public void IgnoresNonSubstituteSpecimens()
        {
            // Arrange
            var context  = Substitute.For <ISpecimenContext>();
            var specimen = new ConcreteTypeWithSealedMembers();
            var sut      = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(specimen, context)));

            context.DidNotReceiveWithAnyArgs().Resolve(null);
        }
        public void IgnoresIndexers()
        {
            // Arrange
            var fixture    = new Fixture();
            var frozenInt  = fixture.Freeze <int>();
            var substitute = Substitute.For <TypeWithIndexer>();
            var sut        = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(substitute, new SpecimenContext(fixture))));

            Assert.NotEqual(frozenInt, substitute[2]);
        }
        public void IgnoresGetOnlyProperties()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithGetOnlyProperty>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            //Exercise system and verify outcome
            Assert.Null(Record.Exception(() => sut.Execute(substitute, new SpecimenContext(fixture))));

            Assert.NotEqual(frozenString, substitute.GetOnlyProperty);
        }
 public void InitializesPublicFields()
 {
     // Fixture setup
     var fixture = new Fixture();
     var frozenString = fixture.Freeze<string>();
     var substitute = Substitute.For<TypeWithPublicField>();
     var sut = new NSubstituteSealedPropertiesCommand();
     // Exercise system
     sut.Execute(substitute, new SpecimenContext(fixture));
     // Verify outcome
     Assert.Equal(frozenString, substitute.Field);
     // Teardown
 }
        public void IgnoresLiteralFields()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithConstField>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(substitute, new SpecimenContext(fixture))));

            Assert.NotEqual(frozenString, TypeWithConstField.ConstField);
        }
        public void IgnoresVirtualProperties()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithVirtualMembers>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenString, substitute.VirtualProperty);
        }
        public void IgnoresPropertiesWithPrivateSetter()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithPropertyWithPrivateSetter>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(substitute, new SpecimenContext(fixture))));

            Assert.NotEqual(frozenString, substitute.PropertyWithPrivateSetter);
        }
        public void IgnoresIndexers()
        {
            // Fixture setup
            var fixture    = new Fixture();
            var frozenInt  = fixture.Freeze <int>();
            var substitute = Substitute.For <TypeWithIndexer>();
            var sut        = new NSubstituteSealedPropertiesCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenInt, substitute[2]);
        }
        public void InitializesPublicFields()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithPublicField>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Act
            sut.Execute(substitute, new SpecimenContext(fixture));
            // Assert
            Assert.Equal(frozenString, substitute.Field);
        }
        public void InitializesPublicFields()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithPublicField>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Exercise system
            sut.Execute(substitute, new SpecimenContext(fixture));
            // Verify outcome
            Assert.Equal(frozenString, substitute.Field);
            // Teardown
        }
 public void InitializesSealedPropertyUsingContext()
 {
     // Fixture setup
     var fixture = new Fixture();
     var frozenString = fixture.Freeze<string>();
     var substitute = Substitute.For<TypeWithSealedMembers>();
     var sut = new NSubstituteSealedPropertiesCommand();
     // Exercise system
     sut.Execute(substitute, new SpecimenContext(fixture));
     // Verify outcome
     Assert.Equal(frozenString, substitute.ExplicitlySealedProperty);
     Assert.Equal(frozenString, substitute.ImplicitlySealedProperty);
     // Teardown
 }
        public void InitializesSealedPropertyUsingContext()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithSealedMembers>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Act
            sut.Execute(substitute, new SpecimenContext(fixture));
            // Assert
            Assert.Equal(frozenString, substitute.ExplicitlySealedProperty);
            Assert.Equal(frozenString, substitute.ImplicitlySealedProperty);
        }
        public void InitializesSealedPropertyUsingContext()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var substitute   = Substitute.For <TypeWithSealedMembers>();
            var sut          = new NSubstituteSealedPropertiesCommand();

            // Exercise system
            sut.Execute(substitute, new SpecimenContext(fixture));
            // Verify outcome
            Assert.Equal(frozenString, substitute.ExplicitlySealedProperty);
            Assert.Equal(frozenString, substitute.ImplicitlySealedProperty);
            // Teardown
        }
        public void IgnoresPrivateProperties()
        {
            // Arrange
            var fixture         = new Fixture();
            var frozenString    = fixture.Freeze <string>();
            var substitute      = Substitute.For <TypeWithPrivateProperty>();
            var privateProperty = typeof(TypeWithPrivateProperty).GetProperty("PrivateProperty", BindingFlags.Instance | BindingFlags.NonPublic);

            var sut = new NSubstituteSealedPropertiesCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(substitute, new SpecimenContext(fixture))));

            Assert.NotEqual(frozenString, privateProperty.GetValue(substitute, null));
        }
        public void IgnoresPrivateProperties()
        {
            // Fixture setup
            var fixture         = new Fixture();
            var frozenString    = fixture.Freeze <string>();
            var substitute      = Substitute.For <TypeWithPrivateProperty>();
            var privateProperty = typeof(TypeWithPrivateProperty)
                                  .GetProperty("PrivateProperty",
                                               BindingFlags.Instance | BindingFlags.NonPublic);

            var sut = new NSubstituteSealedPropertiesCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenString, privateProperty.GetValue(substitute, null));
        }
        public void IgnoresPrivateProperties()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenString = fixture.Freeze<string>();
            var substitute = Substitute.For<TypeWithPrivateProperty>();
            var privateProperty = typeof(TypeWithPrivateProperty)
                .GetProperty("PrivateProperty",
                             BindingFlags.Instance | BindingFlags.NonPublic);

            var sut = new NSubstituteSealedPropertiesCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenString, privateProperty.GetValue(substitute, null));
        }
        public void IgnoresNonSubstituteSpecimens()
        {
            // Fixture setup
            var context = Substitute.For<ISpecimenContext>();
            var specimen = new ConcreteTypeWithSealedMembers();
            var sut = new NSubstituteSealedPropertiesCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(specimen, context));

            context.DidNotReceiveWithAnyArgs().Resolve(null);
        }
        public void IgnoresIndexers()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenInt = fixture.Freeze<int>();
            var substitute = Substitute.For<TypeWithIndexer>();
            var sut = new NSubstituteSealedPropertiesCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(substitute, new SpecimenContext(fixture)));

            Assert.NotEqual(frozenInt, substitute[2]);
        }