public void CheckIsTyposquattingMultiCollisionsWithoutSameUser()
        {
            // Arrange
            var uploadedPackageId = "microsoft_netframework.v1";

            _pacakgeRegistrationsList = _pacakgeRegistrationsList.Concat(new PackageRegistration[]
            {
                new PackageRegistration {
                    Id            = "microsoft-netframework-v1",
                    DownloadCount = new Random().Next(0, 10000),
                    IsVerified    = true,
                    Owners        = new List <User> {
                        new User()
                        {
                            Username = string.Format("owner{0}", _packageIds.Count() + 2), Key = _packageIds.Count() + 2
                        }
                    }
                }
            });
            _packageService
            .Setup(x => x.GetAllPackageRegistrations())
            .Returns(_pacakgeRegistrationsList);

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.True(typosquattingCheckResult);
            Assert.Equal(2, typosquattingCheckCollisionIds.Count);
        }
        public void CheckTelemetryServiceLogOriginalUploadedPackageId()
        {
            // Arrange
            var uploadedPackageId = "microsoft_netframework.v1";
            var newService        = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            _telemetryService.Verify(
                x => x.TrackMetricForTyposquattingChecklistRetrievalTime(uploadedPackageId, It.IsAny <TimeSpan>()),
                Times.Once);

            _telemetryService.Verify(
                x => x.TrackMetricForTyposquattingAlgorithmProcessingTime(uploadedPackageId, It.IsAny <TimeSpan>()),
                Times.Once);

            _telemetryService.Verify(
                x => x.TrackMetricForTyposquattingCheckResultAndTotalTime(
                    uploadedPackageId,
                    It.IsAny <TimeSpan>(),
                    It.IsAny <bool>(),
                    It.IsAny <List <string> >(),
                    It.IsAny <int>()),
                Times.Once);

            _telemetryService.Verify(
                x => x.TrackMetricForTyposquattingOwnersCheckTime(uploadedPackageId, It.IsAny <TimeSpan>()),
                Times.Once);
        }
        public void CheckNotTyposquattingByDifferentOwnersTest()
        {
            // Arrange
            var uploadedPackageId = "new_package_for_testing";
            var newService        = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.False(typosquattingCheckResult);
            Assert.Equal(0, typosquattingCheckCollisionIds.Count);
        }
        public void CheckTyposquattingNullUploadedPackageId()
        {
            // Arrange
            string uploadedPackageId = null;

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var exception = Assert.Throws <ArgumentNullException>(
                () => newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds));

            // Assert
            Assert.Equal(nameof(uploadedPackageId), exception.ParamName);
        }
        public void CheckIsTyposquattingByDifferentOwnersTest()
        {
            // Arrange
            var uploadedPackageId = "Mícrosoft.NetFramew0rk.v1";
            var newService        = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.True(typosquattingCheckResult);
            Assert.Equal(1, typosquattingCheckCollisionIds.Count);
            Assert.Equal("microsoft_netframework_v1", typosquattingCheckCollisionIds[0]);
        }
        public void CheckNotTyposquattingBySameOwnersTest()
        {
            // Arrange
            _uploadedPackageOwner.Username = "******";
            _uploadedPackageOwner.Key      = 1;
            var uploadedPackageId = "microsoft_netframework.v1";

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.False(typosquattingCheckResult);
            Assert.Equal(0, typosquattingCheckCollisionIds.Count);
        }
        public void CheckNotTyposquattingBlockUserNotEnabled()
        {
            // Arrange
            var uploadedPackageId = "new_package_for_testing";

            _contentObjectService
            .Setup(x => x.TyposquattingConfiguration.IsBlockUsersEnabled)
            .Returns(false);

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.False(typosquattingCheckResult);
            Assert.Equal(0, typosquattingCheckCollisionIds.Count);
        }
        public void CheckTyposquattingEmptyChecklist()
        {
            // Arrange
            var uploadedPackageId = "microsoft_netframework_v1";

            _packageService
            .Setup(x => x.GetAllPackageRegistrations())
            .Returns(new List <PackageRegistration>().AsQueryable());

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.False(typosquattingCheckResult);
            Assert.Equal(0, typosquattingCheckCollisionIds.Count);
        }
        public void CheckNotTyposquattingWithinReservedNameSpace()
        {
            // Arrange
            var uploadedPackageId = "microsoft_netframework.v1";

            _reservedNamespaceService
            .Setup(x => x.GetReservedNamespacesForId(It.IsAny <string>()))
            .Returns(new List <ReservedNamespace> {
                new ReservedNamespace()
            });

            var newService = new TyposquattingService(_contentObjectService.Object, _packageService.Object, _reservedNamespaceService.Object, _telemetryService.Object);

            // Act
            var typosquattingCheckResult = newService.IsUploadedPackageIdTyposquatting(uploadedPackageId, _uploadedPackageOwner, out List <string> typosquattingCheckCollisionIds);

            // Assert
            Assert.False(typosquattingCheckResult);
            Assert.Equal(0, typosquattingCheckCollisionIds.Count);
        }