From 89a713d35b38633ced896490aa33176c968233fa Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 08:17:55 +0100 Subject: [PATCH 01/14] Added the documentation. --- README.md | 1 + doc/company.md | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 doc/company.md diff --git a/README.md b/README.md index e766301..8f0d7e9 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ Contents - [Faker.Book](doc/book.md) - [Faker.Boolean](doc/boolean.md) - [Faker.Business](doc/business.md) + - [Faker.Company](doc/company.md) - [Faker.Date](doc/date.md) - [Faker.Fake](doc/fake.md) - [Faker.Lorem](doc/lorem.md) diff --git a/doc/company.md b/doc/company.md new file mode 100644 index 0000000..0efec8f --- /dev/null +++ b/doc/company.md @@ -0,0 +1,59 @@ +# Faker.Company + +```cs +Faker.Company.Name() //=> "Hirthe-Ritchie" + +Faker.Company.Suffix() //=> "Group" + +Faker.Company.Industry() //=> "Information Services" + +// Generate a buzzword-laden catch phrase. +Faker.Company.CatchPhrase() //=> "Business-focused coherent parallelism" + +Faker.Company.Buzzword() //=> "Business-focused" + +// When a straight answer won't do, BS to the rescue! +Faker.Company.Bs() //=> "empower one-to-one web-readiness" + +// Generate US employee identification numbers +Faker.Company.Ein() //=> "34-8488813" + +// Generate "Data Universal Numbering System" +Faker.Company.DunsNumber() //=> "08-341-3736" + +// Get a random company logo url in PNG format. +Faker.Company.Logo() //=> "https://pigment.Github.Com/fake-logos/logos/medium/color/5.png" + +Faker.Company.Type() //=> "Privately Held" + +#//Get a random profession +Faker.Company.Profession() //=> "firefighter" + +// Generate country specific identifiers + +Faker.Company.SwedishOrganisationNumber() //=> "7962578022" + +Faker.Company.CzechOrganisationNumber() //=> "77778171" + +Faker.Company.FrenchSirenNumber() //=> "819489626" + +Faker.Company.FrenchSiretNumber() //=> "81948962600013" + +Faker.Company.NorwegianOrganisationNumber() //=> "839071558" + +Faker.Company.AustralianBusinessNumber() //=> "81137773602" + +Faker.Company.SpanishOrganisationNumber() //=> "P2344979" + +// Get a random Polish taxpayer identification number +Faker.Company.PolishTaxpayerIdentificationNumber() //=> "1060000062" + +// Get a random Polish register of national economy number +Faker.Company.PolishRegisterOfNationalEconomy() //=> "123456785" + +// Generate South African company registration numbers: +Faker.Company.SouthAfricanPtyLtdRegistrationNumber() //=> "5301/714689/07" +Faker.Company.SouthAfricanCloseCorporationRegistrationNumber() //=> "CK74/7585/23" +Faker.Company.SouthAfricanListedCompanyRegistrationNumber() //=> "7039/3135/06" +Faker.Company.SouthAfricanTrustRegistrationNumber() //=> "IT38/6489900" +``` From 69633a24901b67c3397c28dbb53b87dc9797a2dc Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 08:19:55 +0100 Subject: [PATCH 02/14] Started implementing the CompanyFaker. --- src/FakerDotNet/Data/CompanyData.cs | 720 ++++++++++++++++++ src/FakerDotNet/Fakers/CompanyFaker.cs | 174 +++++ .../Fakers/CompanyFakerTests.cs | 221 ++++++ 3 files changed, 1115 insertions(+) create mode 100644 src/FakerDotNet/Data/CompanyData.cs create mode 100644 src/FakerDotNet/Fakers/CompanyFaker.cs create mode 100644 tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs diff --git a/src/FakerDotNet/Data/CompanyData.cs b/src/FakerDotNet/Data/CompanyData.cs new file mode 100644 index 0000000..6416f35 --- /dev/null +++ b/src/FakerDotNet/Data/CompanyData.cs @@ -0,0 +1,720 @@ +using System.Collections.Generic; + +namespace FakerDotNet.Data +{ + internal static class CompanyData + { + public static readonly IEnumerable Suffixes = new[] + { + "Inc", + "and Sons", + "LLC", + "Group" + }; + + public static readonly IEnumerable> Buzzwords = new[] + { + new[] + { + "Adaptive", + "Advanced", + "Ameliorated", + "Assimilated", + "Automated", + "Balanced", + "Business-focused", + "Centralized", + "Cloned", + "Compatible", + "Configurable", + "Cross-group", + "Cross-platform", + "Customer-focused", + "Customizable", + "Decentralized", + "De-engineered", + "Devolved", + "Digitized", + "Distributed", + "Diverse", + "Down-sized", + "Enhanced", + "Enterprise-wide", + "Ergonomic", + "Exclusive", + "Expanded", + "Extended", + "Face to face", + "Focused", + "Front-line", + "Fully-configurable", + "Function-based", + "Fundamental", + "Future-proofed", + "Grass-roots", + "Horizontal", + "Implemented", + "Innovative", + "Integrated", + "Intuitive", + "Inverse", + "Managed", + "Mandatory", + "Monitored", + "Multi-channelled", + "Multi-lateral", + "Multi-layered", + "Multi-tiered", + "Networked", + "Object-based", + "Open-architected", + "Open-source", + "Operative", + "Optimized", + "Optional", + "Organic", + "Organized", + "Persevering", + "Persistent", + "Phased", + "Polarised", + "Pre-emptive", + "Proactive", + "Profit-focused", + "Profound", + "Programmable", + "Progressive", + "Public-key", + "Quality-focused", + "Reactive", + "Realigned", + "Re-contextualized", + "Re-engineered", + "Reduced", + "Reverse-engineered", + "Right-sized", + "Robust", + "Seamless", + "Secured", + "Self-enabling", + "Sharable", + "Stand-alone", + "Streamlined", + "Switchable", + "Synchronised", + "Synergistic", + "Synergized", + "Team-oriented", + "Total", + "Triple-buffered", + "Universal", + "Up-sized", + "Upgradable", + "User-centric", + "User-friendly", + "Versatile", + "Virtual", + "Visionary", + "Vision-oriented" + }, + new[] + { + "24 hour", + "24/7", + "3rd generation", + "4th generation", + "5th generation", + "6th generation", + "actuating", + "analyzing", + "asymmetric", + "asynchronous", + "attitude-oriented", + "background", + "bandwidth-monitored", + "bi-directional", + "bifurcated", + "bottom-line", + "clear-thinking", + "client-driven", + "client-server", + "coherent", + "cohesive", + "composite", + "context-sensitive", + "contextually-based", + "content-based", + "dedicated", + "demand-driven", + "didactic", + "directional", + "discrete", + "disintermediate", + "dynamic", + "eco-centric", + "empowering", + "encompassing", + "even-keeled", + "executive", + "explicit", + "exuding", + "fault-tolerant", + "foreground", + "fresh-thinking", + "full-range", + "global", + "grid-enabled", + "heuristic", + "high-level", + "holistic", + "homogeneous", + "human-resource", + "hybrid", + "impactful", + "incremental", + "intangible", + "interactive", + "intermediate", + "leading edge", + "local", + "logistical", + "maximized", + "methodical", + "mission-critical", + "mobile", + "modular", + "motivating", + "multimedia", + "multi-state", + "multi-tasking", + "national", + "needs-based", + "neutral", + "next generation", + "non-volatile", + "object-oriented", + "optimal", + "optimizing", + "radical", + "real-time", + "reciprocal", + "regional", + "responsive", + "scalable", + "secondary", + "solution-oriented", + "stable", + "static", + "systematic", + "systemic", + "system-worthy", + "tangible", + "tertiary", + "transitional", + "uniform", + "upward-trending", + "user-facing", + "value-added", + "web-enabled", + "well-modulated", + "zero administration", + "zero defect", + "zero tolerance" + }, + new[] + { + "ability", + "access", + "adapter", + "algorithm", + "alliance", + "analyzer", + "application", + "approach", + "architecture", + "archive", + "artificial intelligence", + "array", + "attitude", + "benchmark", + "budgetary management", + "capability", + "capacity", + "challenge", + "circuit", + "collaboration", + "complexity", + "concept", + "conglomeration", + "contingency", + "core", + "customer loyalty", + "database", + "data-warehouse", + "definition", + "emulation", + "encoding", + "encryption", + "extranet", + "firmware", + "flexibility", + "focus group", + "forecast", + "frame", + "framework", + "function", + "functionalities", + "Graphic Interface", + "groupware", + "Graphical User Interface", + "hardware", + "help-desk", + "hierarchy", + "hub", + "implementation", + "info-mediaries", + "infrastructure", + "initiative", + "installation", + "instruction set", + "interface", + "internet solution", + "intranet", + "knowledge user", + "knowledge base", + "local area network", + "leverage", + "matrices", + "matrix", + "methodology", + "middleware", + "migration", + "model", + "moderator", + "monitoring", + "moratorium", + "neural-net", + "open architecture", + "open system", + "orchestration", + "paradigm", + "parallelism", + "policy", + "portal", + "pricing structure", + "process improvement", + "product", + "productivity", + "project", + "projection", + "protocol", + "secured line", + "service-desk", + "software", + "solution", + "standardization", + "strategy", + "structure", + "success", + "superstructure", + "support", + "synergy", + "system engine", + "task-force", + "throughput", + "time-frame", + "toolset", + "utilisation", + "website", + "workforce" + } + }; + + public static readonly IEnumerable> Bs = new[] + { + new[] + { + "implement", + "utilize", + "integrate", + "streamline", + "optimize", + "evolve", + "transform", + "embrace", + "enable", + "orchestrate", + "leverage", + "reinvent", + "aggregate", + "architect", + "enhance", + "incentivize", + "morph", + "empower", + "envisioneer", + "monetize", + "harness", + "facilitate", + "seize", + "disintermediate", + "synergize", + "strategize", + "deploy", + "brand", + "grow", + "target", + "syndicate", + "synthesize", + "deliver", + "mesh", + "incubate", + "engage", + "maximize", + "benchmark", + "expedite", + "reintermediate", + "whiteboard", + "visualize", + "repurpose", + "innovate", + "scale", + "unleash", + "drive", + "extend", + "engineer", + "revolutionize", + "generate", + "exploit", + "transition", + "e-enable", + "iterate", + "cultivate", + "matrix", + "productize", + "redefine", + "recontextualize" + }, + new[] + { + "clicks-and-mortar", + "value-added", + "vertical", + "proactive", + "robust", + "revolutionary", + "scalable", + "leading-edge", + "innovative", + "intuitive", + "strategic", + "e-business", + "mission-critical", + "sticky", + "one-to-one", + "24/7", + "end-to-end", + "global", + "B2B", + "B2C", + "granular", + "frictionless", + "virtual", + "viral", + "dynamic", + "24/365", + "best-of-breed", + "killer", + "magnetic", + "bleeding-edge", + "web-enabled", + "interactive", + "dot-com", + "sexy", + "back-end", + "real-time", + "efficient", + "front-end", + "distributed", + "seamless", + "extensible", + "turn-key", + "world-class", + "open-source", + "cross-platform", + "cross-media", + "synergistic", + "bricks-and-clicks", + "out-of-the-box", + "enterprise", + "integrated", + "impactful", + "wireless", + "transparent", + "next-generation", + "cutting-edge", + "user-centric", + "visionary", + "customized", + "ubiquitous", + "plug-and-play", + "collaborative", + "compelling", + "holistic", + "rich" + }, + new[] + { + "synergies", + "web-readiness", + "paradigms", + "markets", + "partnerships", + "infrastructures", + "platforms", + "initiatives", + "channels", + "eyeballs", + "communities", + "ROI", + "solutions", + "e-tailers", + "e-services", + "action-items", + "portals", + "niches", + "technologies", + "content", + "vortals", + "supply-chains", + "convergence", + "relationships", + "architectures", + "interfaces", + "e-markets", + "e-commerce", + "systems", + "bandwidth", + "infomediaries", + "models", + "mindshare", + "deliverables", + "users", + "schemas", + "networks", + "applications", + "metrics", + "e-business", + "functionalities", + "experiences", + "web services", + "methodologies" + } + }; + + public static readonly IEnumerable Names = new[] + { + "{Name.LastName} {Suffix}", + "{Name.LastName}-{Name.LastName}", + "{Name.LastName}", +"{Name.LastName} and {Name.LastName}" + }; + + public static readonly IEnumerable Industries = new[] + { + "Defense & Space", + "Computer Hardware", + "Computer Software", + "Computer Networking", + "Internet", + "Semiconductors", + "Telecommunications", + "Law Practice", + "Legal Services", + "Management Consulting", + "Biotechnology", + "Medical Practice", + "Hospital & Health Care", + "Pharmaceuticals", + "Veterinary", + "Medical Devices", + "Cosmetics", + "Apparel & Fashion", + "Sporting Goods", + "Tobacco", + "Supermarkets", + "Food Production", + "Consumer Electronics", + "Consumer Goods", + "Furniture", + "Retail", + "Entertainment", + "Gambling & Casinos", + "Leisure", + "Travel & Tourism", + "Hospitality", + "Restaurants", + "Sports", + "Food & Beverages", + "Motion Pictures and Film", + "Broadcast Media", + "Museums and Institutions", + "Fine Art", + "Performing Arts", + "Recreational Facilities and Services", + "Banking", + "Insurance", + "Financial Services", + "Real Estate", + "Investment Banking", + "Investment Management", + "Accounting", + "Construction", + "Building Materials", + "Architecture & Planning", + "Civil Engineering", + "Aviation & Aerospace", + "Automotive", + "Chemicals", + "Machinery", + "Mining & Metals", + "Oil & Energy", + "Shipbuilding", + "Utilities", + "Textiles", + "Paper & Forest Products", + "Railroad Manufacture", + "Farming", + "Ranching", + "Dairy", + "Fishery", + "Primary / Secondary Education", + "Higher Education", + "Education Management", + "Research", + "Military", + "Legislative Office", + "Judiciary", + "International Affairs", + "Government Administration", + "Executive Office", + "Law Enforcement", + "Public Safety", + "Public Policy", + "Marketing and Advertising", + "Newspapers", + "Publishing", + "Printing", + "Information Services", + "Libraries", + "Environmental Services", + "Package / Freight Delivery", + "Individual & Family Services", + "Religious Institutions", + "Civic & Social Organization", + "Consumer Services", + "Transportationg / Trucking / Railroad", + "Warehousing", + "Airlines / Aviation", + "Maritime", + "Information Technology and Services", + "Market Research", + "Public Relations and Communications", + "Design", + "Nonprofit Organization Management", + "Fund-Raising", + "Program Development", + "Writing and Editing", + "Staffing and Recruiting", + "Professional Training & Coaching", + "Venture Capital & Private Equity", + "Political Organization", + "Translation and Localization", + "Computer Games", + "Events Services", + "Arts and Crafts", + "Electrical / Electronic Manufacturing", + "Online Media", + "Nanotechnology", + "Music", + "Logistics and Supply Chain", + "Plastics", + "Computer & Network Security", + "Wireless", + "Alternative Dispute Resolution", + "Security and Investigations", + "Facilities Services", + "Outsourcing / Offshoring", + "Health", + "Wellness and Fitness", + "Alternative Medicine", + "Media Production", + "Animation", + "Commercial Real Estate", + "Capital Markets", + "Think Tanks", + "Philanthropy", + "E-Learning", + "Wholesale", + "Import and Export", + "Mechanical or Industrial Engineering", + "Photography", + "Human Resources", + "Business Supplies and Equipment", + "Mental Health Care", + "Graphic Design", + "International Trade and Development", + "Wine and Spirits", + "Luxury Goods & Jewelry", + "Renewables & Environment", + "Glass", + "Ceramics & Concrete", + "Packaging and Containers", + "Industrial Automation", + "Government Relations" + }; + + public static readonly IEnumerable Professions = new[] + { + "teacher", + "actor", + "musician", + "philosopher", + "writer", + "doctor", + "accountant", + "agriculturist", + "architect", + "economist", + "engineer", + "interpreter", + "attorney at law", + "advocate", + "librarian", + "statistician", + "human resources", + "firefighter", + "judge", + "police officer", + "astronomer", + "biologist", + "chemist", + "physicist", + "programmer", + "web developer", + "designer" + }; + + public static readonly IEnumerable Types = new[] + { + "Public Company", + "Educational Institution", + "Self-Employed", + "Government Agency", + "Nonprofit", + "Sole Proprietorship", + "Privately Held", + "Partnership" + }; + } +} diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs new file mode 100644 index 0000000..c0d090c --- /dev/null +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -0,0 +1,174 @@ +using System; +using System.Linq; +using System.Text.RegularExpressions; +using FakerDotNet.Data; + +namespace FakerDotNet.Fakers +{ + public interface ICompanyFaker + { + string Name(); + string Suffix(); + string Industry(); + string CatchPhrase(); + string Buzzword(); + string Bs(); + string Ein(); + string DunsNumber(); + string Logo(); + string Type(); + string Profession(); + string SwedishOrganisationNumber(); + string CzechOrganisationNumber(); + string FrenchSirenNumber(); + string FrenchSiretNumber(); + string NorwegianOrganisationNumber(); + string AustralianBusinessNumber(); + string SpanishOrganisationNumber(); + string PolishTaxpayerIdentificationNumber(); + string PolishRegisterOfNationalEconomy(); + string SouthAfricanPtyLtdRegistrationNumber(); + string SouthAfricanCloseCorporationRegistrationNumber(); + string SouthAfricanListedCompanyRegistrationNumber(); + string SouthAfricanTrustRegistrationNumber(); + } + + internal class CompanyFaker : ICompanyFaker + { + private readonly IFakerContainer _fakerContainer; + + public CompanyFaker(IFakerContainer fakerContainer) + { + _fakerContainer = fakerContainer; + } + + public string Name() + { + return Parse(_fakerContainer.Random.Element(CompanyData.Names)); + } + + public string Suffix() + { + return _fakerContainer.Random.Element(CompanyData.Suffixes); + } + + public string Industry() + { + return _fakerContainer.Random.Element(CompanyData.Industries); + } + + public string CatchPhrase() + { + return string.Join(" ", CompanyData.Buzzwords.Select(_fakerContainer.Random.Element)); + } + + public string Buzzword() + { + return _fakerContainer.Random.Element(CompanyData.Buzzwords.SelectMany(x => x)); + } + + public string Bs() + { + return string.Join(" ", CompanyData.Bs.Select(_fakerContainer.Random.Element)); + } + + public string Ein() + { + throw new NotImplementedException(); + } + + public string DunsNumber() + { + throw new NotImplementedException(); + } + + public string Logo() + { + var n = _fakerContainer.Number.Between(1, 13); + return $"https://pigment.github.io/fake-logos/logos/medium/color/{n}.png"; + } + + public string Type() + { + return _fakerContainer.Random.Element(CompanyData.Types); + } + + public string Profession() + { + return _fakerContainer.Random.Element(CompanyData.Professions); + } + + public string SwedishOrganisationNumber() + { + throw new NotImplementedException(); + } + + public string CzechOrganisationNumber() + { + throw new NotImplementedException(); + } + + public string FrenchSirenNumber() + { + throw new NotImplementedException(); + } + + public string FrenchSiretNumber() + { + throw new NotImplementedException(); + } + + public string NorwegianOrganisationNumber() + { + throw new NotImplementedException(); + } + + public string AustralianBusinessNumber() + { + throw new NotImplementedException(); + } + + public string SpanishOrganisationNumber() + { + throw new NotImplementedException(); + } + + public string PolishTaxpayerIdentificationNumber() + { + throw new NotImplementedException(); + } + + public string PolishRegisterOfNationalEconomy() + { + throw new NotImplementedException(); + } + + public string SouthAfricanPtyLtdRegistrationNumber() + { + throw new NotImplementedException(); + } + + public string SouthAfricanCloseCorporationRegistrationNumber() + { + throw new NotImplementedException(); + } + + public string SouthAfricanListedCompanyRegistrationNumber() + { + throw new NotImplementedException(); + } + + public string SouthAfricanTrustRegistrationNumber() + { + throw new NotImplementedException(); + } + + private string Parse(string format) + { + var text = Regex.Replace(format, @"\{(\w+)\}", @"{Company.$1}"); + + return _fakerContainer.Fake.F(text); + } + } +} + diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs new file mode 100644 index 0000000..35ab87d --- /dev/null +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -0,0 +1,221 @@ +using System.Collections.Generic; +using System.Linq; +using FakeItEasy; +using FakerDotNet.Data; +using FakerDotNet.Fakers; +using NUnit.Framework; + +namespace FakerDotNet.Tests.Fakers +{ + [TestFixture] + [Parallelizable] + public class CompanyFakerTests + { + [SetUp] + public void SetUp() + { + _fakerContainer = A.Fake(); + _companyFaker = new CompanyFaker(_fakerContainer); + + A.CallTo(() => _fakerContainer.Fake).Returns(new FakeFaker(_fakerContainer)); + } + + private IFakerContainer _fakerContainer; + private ICompanyFaker _companyFaker; + + [Test] + public void Name_returns_a_company_name() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Names)) + .Returns("{Name.LastName}-{Name.LastName}"); + A.CallTo(() => _fakerContainer.Name.LastName()) + .ReturnsNextFromSequence("Hirthe", "Ritchie"); + + Assert.AreEqual("Hirthe-Ritchie", _companyFaker.Name()); + } + + [Test] + public void Name_can_handle_calling_self_from_IFakeFaker() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Names)) + .Returns("{Name.LastName} {Suffix}"); + A.CallTo(() => _fakerContainer.Name.LastName()) + .Returns("Awesome"); + A.CallTo(() => _fakerContainer.Company.Suffix()) + .Returns("Inc"); + + Assert.AreEqual("Awesome Inc", _companyFaker.Name()); + } + + [Test] + public void Suffix_returns_the_suffix_for_a_company() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Suffixes)) + .Returns("Group"); + + Assert.AreEqual("Group", _companyFaker.Suffix()); + } + + [Test] + public void Industry_returns_an_industry() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Industries)) + .Returns("Information Services"); + + Assert.AreEqual("Information Services", _companyFaker.Industry()); + } + + [Test] + public void CatchPhrase_returns_a_catch_phrase() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Buzzwords.ElementAt(0))) + .Returns("Business-focused"); + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Buzzwords.ElementAt(1))) + .Returns("coherent"); + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Buzzwords.ElementAt(2))) + .Returns("parallelism"); + + Assert.AreEqual("Business-focused coherent parallelism", _companyFaker.CatchPhrase()); + } + + [Test] + public void Buzzword_returns_a_buzzword() + { + A.CallTo(() => _fakerContainer.Random.Element( + A>.That.IsSameSequenceAs(CompanyData.Buzzwords.SelectMany(x => x)))) + .Returns("Business-focused"); + + Assert.AreEqual("Business-focused", _companyFaker.Buzzword()); + } + + [Test] + public void Bs_returns_some_bs() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Bs.ElementAt(0))) + .Returns("empower"); + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Bs.ElementAt(1))) + .Returns("one-to-one"); + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Bs.ElementAt(2))) + .Returns("web-readiness"); + + Assert.AreEqual("empower one-to-one web-readiness", _companyFaker.Bs()); + } + + [Test] + public void Ein_returns_an_EIN() + { + Assert.Fail(); + } + + [Test] + public void DunsNumber_returns_a_DUNS_number() + { + Assert.Fail(); + } + + [Test] + public void Logo_returns_a_company_logo() + { + A.CallTo(() => _fakerContainer.Number.Between(1, 13)) + .Returns(5); + + Assert.AreEqual("https://pigment.github.io/fake-logos/logos/medium/color/5.png", _companyFaker.Logo()); + } + + [Test] + public void Type_returns_a_type_of_company() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Types)) + .Returns("Privately Held"); + + Assert.AreEqual("Privately Held", _companyFaker.Type()); + } + + [Test] + public void Profession_returns_a_profession() + { + A.CallTo(() => _fakerContainer.Random.Element(CompanyData.Professions)) + .Returns("firefighter"); + + Assert.AreEqual("firefighter", _companyFaker.Profession()); + } + + [Test] + public void SwedishOrganisationNumber_returns_a_swedish_organisation_number() + { + Assert.Fail(); + } + + [Test] + public void CzechOrganisationNumber_returns_a_czech_organisation_number() + { + Assert.Fail(); + } + + [Test] + public void FrenchSirenNumber_returns_a_french_siren_number() + { + Assert.Fail(); + } + + [Test] + public void FrenchSiretNumber_returns_a_french_siret_number() + { + Assert.Fail(); + } + + [Test] + public void NorwegianOrganisationNumber_returns_a_norwegian_organisation_number() + { + Assert.Fail(); + } + + [Test] + public void AustralianBusinessNumber_returns_an_australian_business_number() + { + Assert.Fail(); + } + + [Test] + public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() + { + Assert.Fail(); + } + + [Test] + public void PolishTaxpayerIdentificationNumber_returns_a_polish_taxpayer_identification_number() + { + Assert.Fail(); + } + + [Test] + public void PolishRegisterOfNationalEconomy_returns_a_polish_register_of_national_economy() + { + Assert.Fail(); + } + + [Test] + public void SouthAfricanPtyLtdRegistrationNumber_returns_a_south_african_pty_ltd_registration_number() + { + Assert.Fail(); + } + + [Test] + public void SouthAfricanCloseCorporationRegistrationNumber_returns_a_south_african_close_corporation_registration_number() + { + Assert.Fail(); + } + + [Test] + public void SouthAfricanListedCompanyRegistrationNumber_returns_a_south_african_listed_company_registration_number() + { + Assert.Fail(); + } + + [Test] + public void SouthAfricanTrustRegistrationNumber_returns_a_south_african_trust_registration_number() + { + Assert.Fail(); + } + } +} From dc908698490dbd07d1825812725c51452e8e5cc2 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 08:20:10 +0100 Subject: [PATCH 03/14] Added the Company faker to the faker container and main faker class. --- src/FakerDotNet/Faker.cs | 1 + src/FakerDotNet/FakerContainer.cs | 3 +++ tests/FakerDotNet.Tests/FakerContainerTests.cs | 9 +++++++-- tests/FakerDotNet.Tests/FakerTests.cs | 6 ++++++ 4 files changed, 17 insertions(+), 2 deletions(-) diff --git a/src/FakerDotNet/Faker.cs b/src/FakerDotNet/Faker.cs index 92b964c..c09f8c1 100644 --- a/src/FakerDotNet/Faker.cs +++ b/src/FakerDotNet/Faker.cs @@ -11,6 +11,7 @@ public static class Faker public static IBookFaker Book { get; } = Container.Book; public static IBooleanFaker Boolean { get; } = Container.Boolean; public static IBusinessFaker Business { get; } = Container.Business; + public static ICompanyFaker Company { get; } = Container.Company; public static IDateFaker Date { get; } = Container.Date; public static IFakeFaker Fake { get; } = Container.Fake; public static IFriendsFaker Friends { get; } = Container.Friends; diff --git a/src/FakerDotNet/FakerContainer.cs b/src/FakerDotNet/FakerContainer.cs index d2b71da..9ad8816 100644 --- a/src/FakerDotNet/FakerContainer.cs +++ b/src/FakerDotNet/FakerContainer.cs @@ -9,6 +9,7 @@ internal interface IFakerContainer IBookFaker Book { get; } IBooleanFaker Boolean { get; } IBusinessFaker Business { get; } + ICompanyFaker Company { get; } IDateFaker Date { get; } IFakeFaker Fake { get; } IFriendsFaker Friends { get; } @@ -30,6 +31,7 @@ public FakerContainer() Book = new BookFaker(this); Boolean = new BooleanFaker(); Business = new BusinessFaker(this); + Company = new CompanyFaker(this); Date = new DateFaker(); Fake = new FakeFaker(this); Friends = new FriendsFaker(this); @@ -47,6 +49,7 @@ public FakerContainer() public IBookFaker Book { get; } public IBooleanFaker Boolean { get; } public IBusinessFaker Business { get; } + public ICompanyFaker Company { get; } public IDateFaker Date { get; } public IFakeFaker Fake { get; } public IFriendsFaker Friends { get; } diff --git a/tests/FakerDotNet.Tests/FakerContainerTests.cs b/tests/FakerDotNet.Tests/FakerContainerTests.cs index 4a1cebf..ca0176f 100644 --- a/tests/FakerDotNet.Tests/FakerContainerTests.cs +++ b/tests/FakerDotNet.Tests/FakerContainerTests.cs @@ -45,6 +45,12 @@ public void Business_returns_IBusinessFaker() Assert.IsInstanceOf(_fakerContainer.Business); } + [Test] + public void Company_returns_ICompanyFaker() + { + Assert.IsInstanceOf(_fakerContainer.Company); + } + [Test] public void Date_returns_IDateFaker() { @@ -56,7 +62,7 @@ public void Fake_returns_IFakeFaker() { Assert.IsInstanceOf(_fakerContainer.Fake); } - + [Test] public void Friends_returns_IFriendsFaker() { @@ -104,6 +110,5 @@ public void Zelda_returns_IZeldaFaker() { Assert.IsInstanceOf(_fakerContainer.Zelda); } - } } diff --git a/tests/FakerDotNet.Tests/FakerTests.cs b/tests/FakerDotNet.Tests/FakerTests.cs index e0851d0..e4b12e1 100644 --- a/tests/FakerDotNet.Tests/FakerTests.cs +++ b/tests/FakerDotNet.Tests/FakerTests.cs @@ -37,6 +37,12 @@ public void Business_returns_IBusinessFaker() Assert.IsInstanceOf(Faker.Business); } + [Test] + public void Company_returns_ICompanyFaker() + { + Assert.IsInstanceOf(Faker.Company); + } + [Test] public void Date_returns_IDateFaker() { From 712ebf38f9c7a3a29b21338aba1b1545b865c90a Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 08:25:49 +0100 Subject: [PATCH 04/14] Fixed logo URL in documentation. --- doc/company.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/company.md b/doc/company.md index 0efec8f..8a3ba4c 100644 --- a/doc/company.md +++ b/doc/company.md @@ -22,7 +22,7 @@ Faker.Company.Ein() //=> "34-8488813" Faker.Company.DunsNumber() //=> "08-341-3736" // Get a random company logo url in PNG format. -Faker.Company.Logo() //=> "https://pigment.Github.Com/fake-logos/logos/medium/color/5.png" +Faker.Company.Logo() //=> "https://pigment.github.io/fake-logos/logos/medium/color/5.png" Faker.Company.Type() //=> "Privately Held" From 1ee67523c1a7b51c737a1cf3c5189ee0c2ddd9e3 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 17:05:55 +0100 Subject: [PATCH 05/14] Implemented the Ein and DunsNumber methods. --- src/FakerDotNet/Fakers/CompanyFaker.cs | 9 +++++++-- .../Fakers/CompanyFakerTests.cs | 16 ++++++++++++++-- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index c0d090c..f0eb5a2 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -74,12 +74,17 @@ public string Bs() public string Ein() { - throw new NotImplementedException(); + return string.Join("-", + _fakerContainer.Number.Number(2), + _fakerContainer.Number.Number(7)); } public string DunsNumber() { - throw new NotImplementedException(); + return string.Join("-", + _fakerContainer.Number.Number(2), + _fakerContainer.Number.Number(3), + _fakerContainer.Number.Number(4)); } public string Logo() diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index 35ab87d..ceebf57 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -104,13 +104,25 @@ public void Bs_returns_some_bs() [Test] public void Ein_returns_an_EIN() { - Assert.Fail(); + A.CallTo(() => _fakerContainer.Number.Number(2)) + .Returns("34"); + A.CallTo(() => _fakerContainer.Number.Number(7)) + .Returns("8488813"); + + Assert.AreEqual("34-8488813", _companyFaker.Ein()); } [Test] public void DunsNumber_returns_a_DUNS_number() { - Assert.Fail(); + A.CallTo(() => _fakerContainer.Number.Number(2)) + .Returns("08"); + A.CallTo(() => _fakerContainer.Number.Number(3)) + .Returns("341"); + A.CallTo(() => _fakerContainer.Number.Number(4)) + .Returns("3736"); + + Assert.AreEqual("08-341-3736", _companyFaker.DunsNumber()); } [Test] From 7ae7632db13036c754ea6d3451168a6f3c9a86b5 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 17 Oct 2018 17:06:14 +0100 Subject: [PATCH 06/14] Added the assertions to the non-implemented tests...expect failure. --- .../Fakers/CompanyFakerTests.cs | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index ceebf57..b2d870e 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -155,79 +155,79 @@ public void Profession_returns_a_profession() [Test] public void SwedishOrganisationNumber_returns_a_swedish_organisation_number() { - Assert.Fail(); + Assert.AreEqual("7962578022", _companyFaker.SwedishOrganisationNumber()); } [Test] public void CzechOrganisationNumber_returns_a_czech_organisation_number() { - Assert.Fail(); + Assert.AreEqual("77778171", _companyFaker.CzechOrganisationNumber()); } [Test] public void FrenchSirenNumber_returns_a_french_siren_number() { - Assert.Fail(); + Assert.AreEqual("819489626", _companyFaker.FrenchSirenNumber()); } [Test] public void FrenchSiretNumber_returns_a_french_siret_number() { - Assert.Fail(); + Assert.AreEqual("81948962600013", _companyFaker.FrenchSiretNumber()); } [Test] public void NorwegianOrganisationNumber_returns_a_norwegian_organisation_number() { - Assert.Fail(); + Assert.AreEqual("839071558", _companyFaker.NorwegianOrganisationNumber()); } [Test] public void AustralianBusinessNumber_returns_an_australian_business_number() { - Assert.Fail(); + Assert.AreEqual("81137773602", _companyFaker.AustralianBusinessNumber()); } [Test] public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() { - Assert.Fail(); + Assert.AreEqual("P2344979", _companyFaker.SpanishOrganisationNumber()); } [Test] public void PolishTaxpayerIdentificationNumber_returns_a_polish_taxpayer_identification_number() { - Assert.Fail(); + Assert.AreEqual("1060000062", _companyFaker.PolishTaxpayerIdentificationNumber()); } [Test] public void PolishRegisterOfNationalEconomy_returns_a_polish_register_of_national_economy() { - Assert.Fail(); + Assert.AreEqual("123456785", _companyFaker.PolishRegisterOfNationalEconomy()); } [Test] public void SouthAfricanPtyLtdRegistrationNumber_returns_a_south_african_pty_ltd_registration_number() { - Assert.Fail(); + Assert.AreEqual("5301/714689/07", _companyFaker.SouthAfricanPtyLtdRegistrationNumber()); } [Test] public void SouthAfricanCloseCorporationRegistrationNumber_returns_a_south_african_close_corporation_registration_number() { - Assert.Fail(); + Assert.AreEqual("CK74/7585/23", _companyFaker.SouthAfricanCloseCorporationRegistrationNumber()); } [Test] public void SouthAfricanListedCompanyRegistrationNumber_returns_a_south_african_listed_company_registration_number() { - Assert.Fail(); + Assert.AreEqual("7039/3135/06", _companyFaker.SouthAfricanListedCompanyRegistrationNumber()); } [Test] public void SouthAfricanTrustRegistrationNumber_returns_a_south_african_trust_registration_number() { - Assert.Fail(); + Assert.AreEqual("IT38/6489900", _companyFaker.SouthAfricanTrustRegistrationNumber()); } } } From 256fbe7526c25da98fbb776a9c7fa973d0eeb7fd Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Fri, 19 Oct 2018 07:49:15 +0100 Subject: [PATCH 07/14] Implemented the Luhn algorithm. --- src/FakerDotNet/Algorithms/LuhnAlgorithm.cs | 27 +++++++++++++++++++ .../Algorithms/LuhnAlgorithmTests.cs | 18 +++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 src/FakerDotNet/Algorithms/LuhnAlgorithm.cs create mode 100644 tests/FakerDotNet.Tests/Algorithms/LuhnAlgorithmTests.cs diff --git a/src/FakerDotNet/Algorithms/LuhnAlgorithm.cs b/src/FakerDotNet/Algorithms/LuhnAlgorithm.cs new file mode 100644 index 0000000..87a6e57 --- /dev/null +++ b/src/FakerDotNet/Algorithms/LuhnAlgorithm.cs @@ -0,0 +1,27 @@ +using System.Linq; + +namespace FakerDotNet.Algorithms +{ + internal static class LuhnAlgorithm + { + public static int GetCheckValue(long number) + { + var sum = $"{number}" + .ToCharArray() + .Reverse() + .Select(c => int.Parse(new string(c, 1))) + .Select((x, i) => i % 2 == 0 ? x * 2 : x) + .Select(SumAllDigits) + .Sum(); + + return sum % 10 == 0 ? 0 : (sum / 10 + 1) * 10 - sum; + } + + private static int SumAllDigits(int number) + { + return $"{number}" + .ToCharArray() + .Sum(c => int.Parse(new string(c, 1))); + } + } +} diff --git a/tests/FakerDotNet.Tests/Algorithms/LuhnAlgorithmTests.cs b/tests/FakerDotNet.Tests/Algorithms/LuhnAlgorithmTests.cs new file mode 100644 index 0000000..dc4b9a5 --- /dev/null +++ b/tests/FakerDotNet.Tests/Algorithms/LuhnAlgorithmTests.cs @@ -0,0 +1,18 @@ +using FakerDotNet.Algorithms; +using NUnit.Framework; + +namespace FakerDotNet.Tests.Algorithms +{ + [TestFixture] + [Parallelizable] + public class LuhnAlgorithmTests + { + [Test] + [TestCase(796257802, 2)] + [TestCase(7992739871, 3)] + public void GetCheckValue_returns_check_value_for_number(long number, int expected) + { + Assert.AreEqual(expected, LuhnAlgorithm.GetCheckValue(number)); + } + } +} From 31264b5895313141b92b8333e81d0b64b9bab852 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Fri, 19 Oct 2018 07:56:05 +0100 Subject: [PATCH 08/14] Implemented the SwedishOrganisationNumber method. --- src/FakerDotNet/Fakers/CompanyFaker.cs | 13 ++++++++++++- tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs | 9 +++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index f0eb5a2..1cd1cbe 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -1,6 +1,7 @@ using System; using System.Linq; using System.Text.RegularExpressions; +using FakerDotNet.Algorithms; using FakerDotNet.Data; namespace FakerDotNet.Fakers @@ -105,7 +106,17 @@ public string Profession() public string SwedishOrganisationNumber() { - throw new NotImplementedException(); + // Get a random Swedish organization number. See more here https://sv.wikipedia.org/wiki/Organisationsnummer + // Valid leading digit: 1, 2, 3, 5, 6, 7, 8, 9 + // Valid third digit: >= 2 + // Last digit is a control digit + var @base = long.Parse(string.Join("", + _fakerContainer.Number.NonZeroDigit(), + _fakerContainer.Number.Digit(), + (int) _fakerContainer.Number.Between(2, 9), + _fakerContainer.Number.Number(6) + )); + return $"{@base}{LuhnAlgorithm.GetCheckValue(@base)}"; } public string CzechOrganisationNumber() diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index b2d870e..9f7cd78 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -155,6 +155,15 @@ public void Profession_returns_a_profession() [Test] public void SwedishOrganisationNumber_returns_a_swedish_organisation_number() { + A.CallTo(() => _fakerContainer.Number.NonZeroDigit()) + .Returns("7"); + A.CallTo(() => _fakerContainer.Number.Digit()) + .Returns("9"); + A.CallTo(() => _fakerContainer.Number.Between(2, 9)) + .Returns(6); + A.CallTo(() => _fakerContainer.Number.Number(6)) + .Returns("257802"); + Assert.AreEqual("7962578022", _companyFaker.SwedishOrganisationNumber()); } From bf76e30b31270d3bdc2a75da411a42484709e6ae Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Sat, 20 Oct 2018 10:11:22 +0100 Subject: [PATCH 09/14] Added an extension method for getting characters out of a string. --- .../Extensions/StringCharactersExtension.cs | 12 ++++++ .../StringCharactersExtensionTests.cs | 40 +++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 src/FakerDotNet/Extensions/StringCharactersExtension.cs create mode 100644 tests/FakerDotNet.Tests/Extensions/StringCharactersExtensionTests.cs diff --git a/src/FakerDotNet/Extensions/StringCharactersExtension.cs b/src/FakerDotNet/Extensions/StringCharactersExtension.cs new file mode 100644 index 0000000..4a548ca --- /dev/null +++ b/src/FakerDotNet/Extensions/StringCharactersExtension.cs @@ -0,0 +1,12 @@ +using System.Linq; + +namespace FakerDotNet.Extensions +{ + internal static class StringCharactersExtension + { + public static string[] Characters(this string text) + { + return $"{text}".ToCharArray().Select(c => new string(c, 1)).ToArray(); + } + } +} \ No newline at end of file diff --git a/tests/FakerDotNet.Tests/Extensions/StringCharactersExtensionTests.cs b/tests/FakerDotNet.Tests/Extensions/StringCharactersExtensionTests.cs new file mode 100644 index 0000000..da658cd --- /dev/null +++ b/tests/FakerDotNet.Tests/Extensions/StringCharactersExtensionTests.cs @@ -0,0 +1,40 @@ +using FakerDotNet.Extensions; +using NUnit.Framework; + +namespace FakerDotNet.Tests.Extensions +{ + [TestFixture] + [Parallelizable] + public class StringCharactersExtensionTests + { + [Test] + public void Characters_returns_each_character_from_string() + { + const string text = "test"; + + var expected = new[] {"t", "e", "s", "t"}; + + CollectionAssert.AreEqual(expected, text.Characters()); + } + + [Test] + public void Characters_returns_empty_array_for_null_string() + { + const string text = null; + + var expected = new string[] { }; + + CollectionAssert.AreEqual(expected, text.Characters()); + } + + [Test] + public void Characters_returns_empty_array_for_empty_string() + { + const string text = ""; + + var expected = new string[] { }; + + CollectionAssert.AreEqual(expected, text.Characters()); + } + } +} \ No newline at end of file From cda059e71bc8a28b7d0bc8e6473910b470e0821d Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Sat, 20 Oct 2018 10:14:15 +0100 Subject: [PATCH 10/14] Implemented the SpanishOrganisationNumber method. --- src/FakerDotNet/Extensions/StringCharactersExtension.cs | 5 +++-- src/FakerDotNet/Fakers/CompanyFaker.cs | 7 ++++++- tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs | 9 +++++++++ 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/src/FakerDotNet/Extensions/StringCharactersExtension.cs b/src/FakerDotNet/Extensions/StringCharactersExtension.cs index 4a548ca..bd700ed 100644 --- a/src/FakerDotNet/Extensions/StringCharactersExtension.cs +++ b/src/FakerDotNet/Extensions/StringCharactersExtension.cs @@ -1,12 +1,13 @@ +using System.Collections.Generic; using System.Linq; namespace FakerDotNet.Extensions { internal static class StringCharactersExtension { - public static string[] Characters(this string text) + public static IEnumerable Characters(this string text) { - return $"{text}".ToCharArray().Select(c => new string(c, 1)).ToArray(); + return $"{text}".ToCharArray().Select(c => new string(c, 1)); } } } \ No newline at end of file diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index 1cd1cbe..922c427 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -3,6 +3,7 @@ using System.Text.RegularExpressions; using FakerDotNet.Algorithms; using FakerDotNet.Data; +using FakerDotNet.Extensions; namespace FakerDotNet.Fakers { @@ -146,7 +147,11 @@ public string AustralianBusinessNumber() public string SpanishOrganisationNumber() { - throw new NotImplementedException(); + // Get a random Spanish organization number. See more here https://es.wikipedia.org/wiki/Número_de_identificación_fiscal + // Valid leading character: A, B, C, D, E, F, G, H, J, N, P, Q, R, S, U, V, W + // 7 digit numbers + var letters = "ABCDEFGHIJKLMNOPQRSTUVW".Characters(); + return $"{_fakerContainer.Random.Element(letters)}{_fakerContainer.Number.Number(7)}"; } public string PolishTaxpayerIdentificationNumber() diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index 9f7cd78..0547543 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -2,6 +2,7 @@ using System.Linq; using FakeItEasy; using FakerDotNet.Data; +using FakerDotNet.Extensions; using FakerDotNet.Fakers; using NUnit.Framework; @@ -200,6 +201,14 @@ public void AustralianBusinessNumber_returns_an_australian_business_number() [Test] public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() { + var letters = "ABCDEFGHIJKLMNOPQRSTUVW".Characters(); + + A.CallTo(() => _fakerContainer.Random.Element( + A>.That.IsSameSequenceAs(letters))) + .Returns("P"); + A.CallTo(() => _fakerContainer.Number.Number(7)) + .Returns("2344979"); + Assert.AreEqual("P2344979", _companyFaker.SpanishOrganisationNumber()); } From 9a19310728884795a22034c4a659da778e2abbfd Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Sat, 20 Oct 2018 10:26:19 +0100 Subject: [PATCH 11/14] Implemented the CzechOrganisationNumber method. --- src/FakerDotNet/Fakers/CompanyFaker.cs | 15 ++++++++++++++- .../FakerDotNet.Tests/Fakers/CompanyFakerTests.cs | 3 +++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index 922c427..49db63a 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; using FakerDotNet.Algorithms; @@ -122,7 +123,19 @@ public string SwedishOrganisationNumber() public string CzechOrganisationNumber() { - throw new NotImplementedException(); + var weights = new[] {8, 7, 6, 5, 4, 3, 2}; + var sum = 0; + var @base = new List(); + + foreach (var weight in weights) + { + @base.Add(int.Parse(_fakerContainer.Number.Digit())); + sum += (weight * @base[@base.Count - 1]); + } + + @base.Add((11 - (sum % 11)) % 10); + + return string.Join("", @base); } public string FrenchSirenNumber() diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index 0547543..cf0b9cf 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -171,6 +171,9 @@ public void SwedishOrganisationNumber_returns_a_swedish_organisation_number() [Test] public void CzechOrganisationNumber_returns_a_czech_organisation_number() { + A.CallTo(() => _fakerContainer.Number.Digit()) + .ReturnsNextFromSequence("7", "7", "7", "7", "8", "1", "7"); + Assert.AreEqual("77778171", _companyFaker.CzechOrganisationNumber()); } From 41a0b52ff5506b80d375a2cf3436a1d57c355a11 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Mon, 22 Oct 2018 10:00:17 +0100 Subject: [PATCH 12/14] Implemented the FrenchSirenNumber and FrenchSiretNumber methods. --- src/FakerDotNet/Fakers/CompanyFaker.cs | 8 ++++++-- tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs | 8 ++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index 49db63a..0e223dd 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -140,12 +140,16 @@ public string CzechOrganisationNumber() public string FrenchSirenNumber() { - throw new NotImplementedException(); + // Get a random French SIREN number. See more here https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%27identification_du_r%C3%A9pertoire_des_entreprises + var @base = int.Parse(_fakerContainer.Number.Number(8)); + return $"{@base}{LuhnAlgorithm.GetCheckValue(@base)}"; } public string FrenchSiretNumber() { - throw new NotImplementedException(); + var location = _fakerContainer.Number.LeadingZeroNumber(3).PadLeft(4, '0'); + var orgNumber = long.Parse(FrenchSirenNumber() + location); + return $"{orgNumber}{LuhnAlgorithm.GetCheckValue(orgNumber)}"; } public string NorwegianOrganisationNumber() diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index cf0b9cf..fe5bbd1 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -180,12 +180,20 @@ public void CzechOrganisationNumber_returns_a_czech_organisation_number() [Test] public void FrenchSirenNumber_returns_a_french_siren_number() { + A.CallTo(() => _fakerContainer.Number.Number(8)) + .Returns("81948962"); + Assert.AreEqual("819489626", _companyFaker.FrenchSirenNumber()); } [Test] public void FrenchSiretNumber_returns_a_french_siret_number() { + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(3)) + .Returns("001"); + A.CallTo(() => _fakerContainer.Number.Number(8)) + .ReturnsNextFromSequence("81948962"); + Assert.AreEqual("81948962600013", _companyFaker.FrenchSiretNumber()); } From cbc256ab3537dd672fadb9a66c7132cfa87a8e6e Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 24 Oct 2018 10:12:15 +0100 Subject: [PATCH 13/14] Removed methods that can be added at a later date --- doc/company.md | 10 -------- src/FakerDotNet/Fakers/CompanyFaker.cs | 24 ------------------- .../Fakers/CompanyFakerTests.cs | 24 ------------------- 3 files changed, 58 deletions(-) diff --git a/doc/company.md b/doc/company.md index 8a3ba4c..39b2afa 100644 --- a/doc/company.md +++ b/doc/company.md @@ -39,18 +39,8 @@ Faker.Company.FrenchSirenNumber() //=> "819489626" Faker.Company.FrenchSiretNumber() //=> "81948962600013" -Faker.Company.NorwegianOrganisationNumber() //=> "839071558" - -Faker.Company.AustralianBusinessNumber() //=> "81137773602" - Faker.Company.SpanishOrganisationNumber() //=> "P2344979" -// Get a random Polish taxpayer identification number -Faker.Company.PolishTaxpayerIdentificationNumber() //=> "1060000062" - -// Get a random Polish register of national economy number -Faker.Company.PolishRegisterOfNationalEconomy() //=> "123456785" - // Generate South African company registration numbers: Faker.Company.SouthAfricanPtyLtdRegistrationNumber() //=> "5301/714689/07" Faker.Company.SouthAfricanCloseCorporationRegistrationNumber() //=> "CK74/7585/23" diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index 0e223dd..ab44fa7 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -25,11 +25,7 @@ public interface ICompanyFaker string CzechOrganisationNumber(); string FrenchSirenNumber(); string FrenchSiretNumber(); - string NorwegianOrganisationNumber(); - string AustralianBusinessNumber(); string SpanishOrganisationNumber(); - string PolishTaxpayerIdentificationNumber(); - string PolishRegisterOfNationalEconomy(); string SouthAfricanPtyLtdRegistrationNumber(); string SouthAfricanCloseCorporationRegistrationNumber(); string SouthAfricanListedCompanyRegistrationNumber(); @@ -152,16 +148,6 @@ public string FrenchSiretNumber() return $"{orgNumber}{LuhnAlgorithm.GetCheckValue(orgNumber)}"; } - public string NorwegianOrganisationNumber() - { - throw new NotImplementedException(); - } - - public string AustralianBusinessNumber() - { - throw new NotImplementedException(); - } - public string SpanishOrganisationNumber() { // Get a random Spanish organization number. See more here https://es.wikipedia.org/wiki/Número_de_identificación_fiscal @@ -171,16 +157,6 @@ public string SpanishOrganisationNumber() return $"{_fakerContainer.Random.Element(letters)}{_fakerContainer.Number.Number(7)}"; } - public string PolishTaxpayerIdentificationNumber() - { - throw new NotImplementedException(); - } - - public string PolishRegisterOfNationalEconomy() - { - throw new NotImplementedException(); - } - public string SouthAfricanPtyLtdRegistrationNumber() { throw new NotImplementedException(); diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index fe5bbd1..e305f19 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -197,18 +197,6 @@ public void FrenchSiretNumber_returns_a_french_siret_number() Assert.AreEqual("81948962600013", _companyFaker.FrenchSiretNumber()); } - [Test] - public void NorwegianOrganisationNumber_returns_a_norwegian_organisation_number() - { - Assert.AreEqual("839071558", _companyFaker.NorwegianOrganisationNumber()); - } - - [Test] - public void AustralianBusinessNumber_returns_an_australian_business_number() - { - Assert.AreEqual("81137773602", _companyFaker.AustralianBusinessNumber()); - } - [Test] public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() { @@ -223,18 +211,6 @@ public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() Assert.AreEqual("P2344979", _companyFaker.SpanishOrganisationNumber()); } - [Test] - public void PolishTaxpayerIdentificationNumber_returns_a_polish_taxpayer_identification_number() - { - Assert.AreEqual("1060000062", _companyFaker.PolishTaxpayerIdentificationNumber()); - } - - [Test] - public void PolishRegisterOfNationalEconomy_returns_a_polish_register_of_national_economy() - { - Assert.AreEqual("123456785", _companyFaker.PolishRegisterOfNationalEconomy()); - } - [Test] public void SouthAfricanPtyLtdRegistrationNumber_returns_a_south_african_pty_ltd_registration_number() { From ff0343de5a7a92fde1c2c922316f76140c6e1dd5 Mon Sep 17 00:00:00 2001 From: Steven Atkinson Date: Wed, 24 Oct 2018 10:13:57 +0100 Subject: [PATCH 14/14] Implemented the SouthAfrican methods. --- src/FakerDotNet/Fakers/CompanyFaker.cs | 19 +++++++++--- .../Fakers/CompanyFakerTests.cs | 30 +++++++++++++++++++ 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs index ab44fa7..4ee8ec5 100644 --- a/src/FakerDotNet/Fakers/CompanyFaker.cs +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -159,22 +159,33 @@ public string SpanishOrganisationNumber() public string SouthAfricanPtyLtdRegistrationNumber() { - throw new NotImplementedException(); + return string.Join("/", + _fakerContainer.Number.LeadingZeroNumber(4), + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(4, 10)), + "07"); } public string SouthAfricanCloseCorporationRegistrationNumber() { - throw new NotImplementedException(); + return string.Join("/", + $"CK{_fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(2, 4))}", + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(4, 10)), + "23"); } public string SouthAfricanListedCompanyRegistrationNumber() { - throw new NotImplementedException(); + return string.Join("/", + _fakerContainer.Number.LeadingZeroNumber(4), + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(4, 10)), + "06"); } public string SouthAfricanTrustRegistrationNumber() { - throw new NotImplementedException(); + return string.Join("/", + $"IT{_fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(2, 4))}", + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(2, 10))); } private string Parse(string format) diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs index e305f19..5c214fa 100644 --- a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -214,24 +214,54 @@ public void SpanishOrganisationNumber_returns_a_spanish_organisation_number() [Test] public void SouthAfricanPtyLtdRegistrationNumber_returns_a_south_african_pty_ltd_registration_number() { + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(4)) + .Returns("5301"); + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(6)) + .Returns("714689"); + A.CallTo(() => _fakerContainer.Number.Between(4, 10)) + .Returns(6); + Assert.AreEqual("5301/714689/07", _companyFaker.SouthAfricanPtyLtdRegistrationNumber()); } [Test] public void SouthAfricanCloseCorporationRegistrationNumber_returns_a_south_african_close_corporation_registration_number() { + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(2)) + .Returns("74"); + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(4)) + .Returns("7585"); + A.CallTo(() => _fakerContainer.Number.Between(2, 4)) + .Returns(2); + A.CallTo(() => _fakerContainer.Number.Between(4, 10)) + .Returns(4); + Assert.AreEqual("CK74/7585/23", _companyFaker.SouthAfricanCloseCorporationRegistrationNumber()); } [Test] public void SouthAfricanListedCompanyRegistrationNumber_returns_a_south_african_listed_company_registration_number() { + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(4)) + .ReturnsNextFromSequence("7039", "3135"); + A.CallTo(() => _fakerContainer.Number.Between(4, 10)) + .Returns(4); + Assert.AreEqual("7039/3135/06", _companyFaker.SouthAfricanListedCompanyRegistrationNumber()); } [Test] public void SouthAfricanTrustRegistrationNumber_returns_a_south_african_trust_registration_number() { + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(2)) + .Returns("38"); + A.CallTo(() => _fakerContainer.Number.LeadingZeroNumber(7)) + .Returns("6489900"); + A.CallTo(() => _fakerContainer.Number.Between(2, 4)) + .Returns(2); + A.CallTo(() => _fakerContainer.Number.Between(2, 10)) + .Returns(7); + Assert.AreEqual("IT38/6489900", _companyFaker.SouthAfricanTrustRegistrationNumber()); } }