diff --git a/README.md b/README.md index 799a340..7ec6554 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,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.GameOfThrones](doc/game_of_thrones.md) diff --git a/doc/company.md b/doc/company.md new file mode 100644 index 0000000..39b2afa --- /dev/null +++ b/doc/company.md @@ -0,0 +1,49 @@ +# 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.io/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.SpanishOrganisationNumber() //=> "P2344979" + +// 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" +``` 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/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/Extensions/StringCharactersExtension.cs b/src/FakerDotNet/Extensions/StringCharactersExtension.cs new file mode 100644 index 0000000..bd700ed --- /dev/null +++ b/src/FakerDotNet/Extensions/StringCharactersExtension.cs @@ -0,0 +1,13 @@ +using System.Collections.Generic; +using System.Linq; + +namespace FakerDotNet.Extensions +{ + internal static class StringCharactersExtension + { + public static IEnumerable Characters(this string text) + { + return $"{text}".ToCharArray().Select(c => new string(c, 1)); + } + } +} \ No newline at end of file diff --git a/src/FakerDotNet/Faker.cs b/src/FakerDotNet/Faker.cs index 0c560db..4ee0245 100644 --- a/src/FakerDotNet/Faker.cs +++ b/src/FakerDotNet/Faker.cs @@ -12,6 +12,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 971b33d..38bec0a 100644 --- a/src/FakerDotNet/FakerContainer.cs +++ b/src/FakerDotNet/FakerContainer.cs @@ -10,6 +10,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; } @@ -37,6 +38,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); @@ -60,6 +62,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/src/FakerDotNet/Fakers/CompanyFaker.cs b/src/FakerDotNet/Fakers/CompanyFaker.cs new file mode 100644 index 0000000..4ee8ec5 --- /dev/null +++ b/src/FakerDotNet/Fakers/CompanyFaker.cs @@ -0,0 +1,199 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using FakerDotNet.Algorithms; +using FakerDotNet.Data; +using FakerDotNet.Extensions; + +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 SpanishOrganisationNumber(); + 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() + { + return string.Join("-", + _fakerContainer.Number.Number(2), + _fakerContainer.Number.Number(7)); + } + + public string DunsNumber() + { + return string.Join("-", + _fakerContainer.Number.Number(2), + _fakerContainer.Number.Number(3), + _fakerContainer.Number.Number(4)); + } + + 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() + { + // 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() + { + 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() + { + // 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() + { + var location = _fakerContainer.Number.LeadingZeroNumber(3).PadLeft(4, '0'); + var orgNumber = long.Parse(FrenchSirenNumber() + location); + return $"{orgNumber}{LuhnAlgorithm.GetCheckValue(orgNumber)}"; + } + + public string SpanishOrganisationNumber() + { + // 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 SouthAfricanPtyLtdRegistrationNumber() + { + return string.Join("/", + _fakerContainer.Number.LeadingZeroNumber(4), + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(4, 10)), + "07"); + } + + public string SouthAfricanCloseCorporationRegistrationNumber() + { + 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() + { + return string.Join("/", + _fakerContainer.Number.LeadingZeroNumber(4), + _fakerContainer.Number.LeadingZeroNumber((int) _fakerContainer.Number.Between(4, 10)), + "06"); + } + + public string SouthAfricanTrustRegistrationNumber() + { + 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) + { + var text = Regex.Replace(format, @"\{(\w+)\}", @"{Company.$1}"); + + return _fakerContainer.Fake.F(text); + } + } +} + 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)); + } + } +} 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 diff --git a/tests/FakerDotNet.Tests/FakerContainerTests.cs b/tests/FakerDotNet.Tests/FakerContainerTests.cs index 6046f2c..a453d52 100644 --- a/tests/FakerDotNet.Tests/FakerContainerTests.cs +++ b/tests/FakerDotNet.Tests/FakerContainerTests.cs @@ -51,6 +51,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() { @@ -116,6 +122,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 acaa970..f4b24b4 100644 --- a/tests/FakerDotNet.Tests/FakerTests.cs +++ b/tests/FakerDotNet.Tests/FakerTests.cs @@ -43,6 +43,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() { diff --git a/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs new file mode 100644 index 0000000..5c214fa --- /dev/null +++ b/tests/FakerDotNet.Tests/Fakers/CompanyFakerTests.cs @@ -0,0 +1,268 @@ +using System.Collections.Generic; +using System.Linq; +using FakeItEasy; +using FakerDotNet.Data; +using FakerDotNet.Extensions; +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() + { + 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() + { + 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] + 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() + { + 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()); + } + + [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()); + } + + [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()); + } + + [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()); + } + + [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()); + } + } +}