Migrates to Pester5+ tests (#59)

#### 📖 Summary

- update Pester tests to Pester5+ compatiple layout
- switch to dotnet base imaged
  - dotnet binary required for publishung powershell modules (Publish-Module)

#### 📑 Test Plan

> 💡 Select your test plan for the code changes.

- [x] Tested via Drone.io pipeline
- [ ] Custom test
- [ ] No test plan

##### Details / Justification

<!-- Add your test details or justification for missing tests here. -->

#### 📚 Additional Notes

<!-- A place for additional detail notes. -->

Co-authored-by: OCram85 <marco.blessing@googlemail.com>
Reviewed-on: #59

src/Certificate/New-CSCertAttribute.Tests.ps1

@@ -0,0 +1,20 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+}
+
+Describe "New-CSCertAttribute" {
+    Context "Basis Tests" -Tag 'Unit' {
+        It "Should not throw" {
+            $AttribParams = @{
+                Country                = 'DE'
+                State                  = 'BW'
+                City                   = 'KA'
+                Organization           = 'IT'
+                OrganizationalUnitName = 'foo'
+                CommonName             = 'MyCert'
+            }
+            { New-CSCertAttribute @AttribParams } | Should -Not -Throw
+        }
+    }
+}

src/Certificate/New-CSCertificate.Tests.ps1

@@ -0,0 +1,33 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "New-CSCertificate" {
+    Context "Basic Tests" -Tag 'Unit' {
+        It "Should not throw" {
+            $attribs = @{
+                Country                = 'DE'
+                State                  = 'BW'
+                City                   = 'KA'
+                Organization           = 'IT'
+                OrganizationalUnitName = 'foo'
+                CommonName             = 'MyCert'
+            }
+            $CertAttribs = @{
+                CRTAttribute = New-CSCertAttribute @attribs
+                KeyName      = Join-Path -Path (Get-TempDir) -ChildPath '/foo.key'
+                CertName     = Join-Path -Path (Get-TempDir) -ChildPath '/cert.pfx'
+            }
+            { New-CSCertificate @CertAttribs } | Should -Not -Throw
+        }
+    }
+}

src/Formats/PSCredentialStore.Certificate.Attribute.ps1xml

@@ -11,22 +11,28 @@
                     <ListEntry>
                         <ListItems>
                             <ListItem>
-                                <PropertyName>Country</PropertyName>
+                                <Label>Country</Label>
+                                <ScriptBlock>$_.Subject.Country</ScriptBlock>
                             </ListItem>
                             <ListItem>
-                                <PropertyName>State</PropertyName>
+                                <Label>State</Label>
+                                <ScriptBlock>$_.Subject.State</ScriptBlock>
                             </ListItem>
                             <ListItem>
-                                <PropertyName>City</PropertyName>
+                                <Label>City</Label>
+                                <ScriptBlock>$_.Subject.City</ScriptBlock>
                             </ListItem>
                             <ListItem>
-                                <PropertyName>Organization</PropertyName>
+                                <Label>Organization</Label>
+                                <ScriptBlock>$_.Subject.Organization</ScriptBlock>
                             </ListItem>
                             <ListItem>
-                                <PropertyName>OrganizationalUnitName</PropertyName>
+                                <Label>OrganizationalUnitName</Label>
+                                <ScriptBlock>$_.Subject.OrganizationalUnitName</ScriptBlock>
                             </ListItem>
                             <ListItem>
-                                <PropertyName>CommonName</PropertyName>
+                                <Label>CommonName</Label>
+                                <ScriptBlock>$_.Subject.CommonName</ScriptBlock>
                             </ListItem>
                         </ListItems>
                     </ListEntry>

src/Item/New-CredentialStoreItem.Tests.ps1

@@ -0,0 +1,146 @@
+[Diagnostics.CodeAnalysis.SuppressMessageAttribute(
+    'PSAvoidUsingConvertToSecureStringWithPlainText',
+    '',
+    Justification = 'just used in pester tests.'
+)]
+[Diagnostics.CodeAnalysis.SuppressMessageAttribute(
+    'PSProvideCommentHelp',
+    '',
+    Justification = 'no need in internal pester helpers.'
+)]
+param ()
+
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "New-CredentialStoreItem" {
+    Context "Private Credential Store tests" {
+        It "Add entry to existing private store." {
+            # Creat a fresh CredentialStore first
+            New-CredentialStore -Force
+
+            [String]$tmp = (65..90) + (97..122) | Get-Random -Count 5 | ForEach-Object { [char]$_ }
+            $tmp = $tmp.Replace(' ', '')
+            $tmpUser = "MyUser"
+            $tmpPwd = "fooobarysdfsfs" | ConvertTo-SecureString -AsPlainText -Force
+            $creds = [PSCredential]::new($tmpUser, $tmpPwd)
+            New-CredentialStoreItem -RemoteHost $tmp -Credential $creds
+            # Had to remove the `{ <exp> } | Shoud Not Throw` because the return would be empty.
+            $content = Get-CredentialStoreItem -RemoteHost $tmp
+            $content.UserName | Should -Be "MyUser"
+            #Cleanup Temp entry
+            $CS = Get-CredentialStore
+            $CS.PSObject.Properties.Remove($tmp)
+            ConvertTo-Json -InputObject $CS | Out-File -FilePath (Get-DefaultCredentialStorePath)
+        }
+    }
+    Context "Test with new shared Credential Store" {
+        It "Create new RemoteHost entry" {
+            # prepare test environment
+            $tmpCS = Join-Path -Path (Get-TempDir) -ChildPath '/CredentialStore.json'
+            New-CredentialStore -Shared -Path $tmpCS -Force
+
+            $UserName = "myuser"
+            $Password = ConvertTo-SecureString -String "mypasswd" -AsPlainText -Force
+            $mycreds = [PSCredential]::new($UserName, $Password)
+            $RemoteHost = "foobar"
+            {
+                New-CredentialStoreItem -Shared -Path $tmpCS -RemoteHost $RemoteHost -Credential $mycreds
+            } | Should -Not -Throw
+            $tmpCS = Get-Content -Path $tmpCS -Raw | ConvertFrom-Json
+            $res = Get-Member -InputObject $tmpCS -Name $RemoteHost -MemberType Properties
+            $res.Name | Should -Be $RemoteHost
+        }
+        It "Adds Item with identifier to shared store" {
+            $tmpCS = Join-Path -Path (Get-TempDir) -ChildPath '/CredentialStore.json'
+            New-CredentialStore -Shared -Path $tmpCS -Force
+
+            $UserName = "myuser"
+            $Password = ConvertTo-SecureString -String "mypasswd" -AsPlainText -Force
+            $mycreds = [PSCredential]::new($UserName, $Password)
+            $RemoteHost = "foobar2"
+            $StoreItemParam = @{
+                Shared     = $true
+                Path       = $tmpCS
+                RemoteHost = $RemoteHost
+                Credential = $mycreds
+                identifier = 'Foo'
+            }
+            New-CredentialStoreItem @StoreItemParam
+            $writtenItem = Get-CredentialStoreItem -Shared -Path $tmpCS -RemoteHost $RemoteHost -Identifier 'Foo'
+            ($writtenItem.UserName -eq $UserName) -and ($writtenItem.Password.Length -gt 0) | Should -Be $true
+        }
+    }
+    Context "Test optional parameter lookup" {
+        It "Test missing Credential" {
+            function global:Get-Credential ([string]$Message) {
+                $UserName = 'testuser'
+                $Password = ConvertTo-SecureString -String "mypasswd" -AsPlainText -Force
+                return [PSCredential]::new($UserName, $Password)
+            }
+            $tmpCS = Join-Path -Path (Get-TempDir) -ChildPath '/CredentialStore.json'
+            New-CredentialStoreItem -Path $tmpCs -Shared -RemoteHost 'foobar3'
+            $writtenItem = Get-CredentialStoreItem -Path $tmpCS -Shared -RemoteHost 'foobar3'
+            $writtenItem.UserName | Should -Be "testuser"
+
+            Remove-Item -Path 'Function:\Get-Credential'
+        }
+
+    }
+    Context "General Exception handling" {
+        Mock Test-CredentialStore { return $false } -ModuleName 'PSCredentialStore'
+        It "Missing CredentialStore should throw" {
+            {
+                New-CredentialStoreItem -Shared -Path '/tmp/missingStore.json' -RemoteHost 'notrelevant'
+            } | Should -Throw "Could not add anything into the given CredentialStore."
+        }
+    }
+    Context "Testing pipeline paramter" {
+        It "Add the item with credential value from pipe" {
+            $UserName = 'pipeUser'
+            $Password = ConvertTo-SecureString -String "pipePasswd" -AsPlainText -Force
+            {
+                [PSCredential]::new($UserName, $Password) | New-CredentialStoreItem -RemoteHost 'PipeHost'
+            } | Should -Not -Throw
+        }
+
+        It "Testing written item" {
+            (Get-CredentialStoreItem -RemoteHost 'PipeHost').UserName | Should -Be 'pipeUser'
+        }
+    }
+    Context "Testing items with certficiate store" {
+        It "Create item in new store with cert store link" {
+            New-CredentialStore -UseCertStore -Force
+
+            $Path = Get-DefaultCredentialStorePath
+            $StoreHome = Split-Path -Path $Path -Parent
+            $CertFile = Join-Path -Path $StoreHome -ChildPath 'PSCredentialStore.pfx'
+            $Cert = Get-PfxCertificate -FilePath $CertFile
+
+            $myStore = [System.Security.Cryptography.X509Certificates.X509Store]::new('My')
+            $myStore.Open("ReadWrite")
+            $myStore.Add($Cert)
+            $MyStore.Close()
+
+            $UserName = 'testuser'
+            $Password = ConvertTo-SecureString -String "mypasswd" -AsPlainText -Force
+
+            [PSCredential]::new($UserName, $Password) | New-CredentialStoreItem -RemoteHost 'foobarcerts'
+
+            $writtenItem = Get-CredentialStoreItem -RemoteHost 'foobarcerts'
+            $writtenItem.UserName | Should -Be "testuser"
+            $writtenItem.GetNetworkCredential().Password | Should -Be 'mypasswd'
+        }
+    }
+
+}

src/ModuleRoot.psm1

@@ -0,0 +1,11 @@
+#region module-definition
+
+#endregion module-definition
+Set-Variable -Name "CSVersion" -Value "2.0.0" -Option Constant -Scope 'Script' -ErrorAction Stop
+
+# Get all child items in the Script path and exclude the Deploy script (if present.)
+$Functions = Get-ChildItem -Path $PSScriptRoot\*.ps1 -Recurse | Where-Object { $_.BaseName -notmatch '.Tests' }
+
+foreach ($Item in $Functions) {
+    . $Item.FullName
+}

src/PSCredentialStore.psd1

@@ -1,7 +1,7 @@
 @{
 
     # Script module or binary module file associated with this manifest.
-    RootModule           = 'PSCredentialStore.psm1'
+    RootModule           = 'ModuleRoot.psm1'
 
     # Version number of this module.
     ModuleVersion        = '0.0.9999'

src/PSCredentialStore.psm1

@@ -1,16 +0,0 @@
-#region module-definition
-
-#endregion module-definition
-Set-Variable -Name "CSVersion" -Value "2.0.0" -Option Constant -Scope 'Script' -ErrorAction Stop
-
-#region dot-sourcing
-# dot-sourcing all module functions. The export is handled via manifest file.
-
-$Items = (Get-ChildItem -Path (Join-Path -Path $PSScriptRoot -ChildPath '*.ps1') -Recurse ).FullName | Where-Object {
-    $_ -notmatch "(Classes|Init)"
-}
-foreach ($Item in $Items) {
-    # Write-Verbose ("dot sourcing file {0}" -f $Item)
-    . $Item
-}
-#endregion dot-sourcing

src/PSModule.Tests.ps1

@@ -1,14 +1,12 @@
 Describe 'Test module meta' {
-    It 'Test manifest file' {
-        $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
-        Test-ModuleManifest -Path $ManifestFile | Should -Be $true
+    Context 'Default tests' -Tag 'Default' {
+        It 'Test manifest file' {
+            $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+            Test-ModuleManifest -Path $ManifestFile | Should -Be $true
+        }
+        It 'Import Module' {
+            $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+            { Import-Module $ManifestFile } | Should -Not -Throw
+        }
     }
-    It 'Import Module' {
-        $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
-        { Import-Module $ManifestFile } | Should -Not -Throw
-    }
-    # Dummy test to force pester error
-    #It 'Force Pester Error' {
-    #    $true | Should -BeFalse
-    #}
 }

src/Private/Get-DefaultCredentialStorePath.Tests.ps1

@@ -0,0 +1,62 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Get-DefaultCredentialStorePath" {
+    Context "Basic syntax test" {
+        It "Test1: Should not throw" {
+            { Get-DefaultCredentialStorePath } | Should -Not -Throw
+        }
+    }
+
+    Context "Private Type" {
+        It "Should return correct paths" {
+            $Path = Get-DefaultCredentialStorePath
+            #Write-Verbose -Message ('Delivered path is: {0}' -f $Path) -Verbose
+            if ($Env:APPVEYOR) {
+                $PathRef = Join-Path -Path $Env:APPDATA -ChildPath 'CredentialStore.json'
+                $Path | Should -Be $PathRef
+            }
+            elseif ($ENV:TRAVIS) {
+                if ($IsLinux) {
+                    $PathRef = Join-Path -Path $Env:HOME -ChildPath 'CredentialStore.json'
+                    $Path | Should -Be $PathRef
+                }
+                elseif ($IsMacOS) {
+                    $PathRef = Join-Path -Path $Env:HOME -ChildPath 'CredentialStore.json'
+                    $Path | Should -Be $PathRef
+                }
+            }
+        }
+    }
+
+    Context "Shared Type" {
+        It "Should return correct paths" {
+            $Path = Get-DefaultCredentialStorePath -Shared
+            #Write-Verbose -Message ('Delivered path is: {0}' -f $Path) -Verbose
+            if ($Env:APPVEYOR) {
+                $PathRef = Join-Path -Path $env:ProgramData -ChildPath 'PSCredentialStore/CredentialStore.json'
+                $Path | Should -Be $PathRef
+            }
+            elseif ($ENV:TRAVIS) {
+                if ($IsLinux) {
+                    $PathRef = Join-Path -Path '/var/opt' -ChildPath 'PSCredentialStore/CredentialStore.json'
+                    $Path | Should -Be $PathRef
+                }
+                elseif ($IsMacOS) {
+                    $PathRef = Join-Path -Path '/var/opt' -ChildPath 'PSCredentialStore/CredentialStore.json'
+                    $Path | Should -Be $PathRef
+                }
+            }
+        }
+    }
+}

src/Private/Get-ModuleBase.Tests.ps1

@@ -0,0 +1,20 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Get-ModuleBase" {
+    Context "Basic syntax check" {
+        It "Test1: Should not throw" {
+            { Get-ModuleBase } | Should -Not -Throw
+        }
+    }
+}

src/Private/Get-RandomAESKey.Tests.ps1

@@ -0,0 +1,26 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Get-RandomKey" {
+    Context "Basic input tests" {
+        It "Test1: Should not throw " {
+            { Get-RandomAESKey } | Should -Not -Throw
+        }
+    }
+    Context "Basic syntax check" {
+        It "Test2: Should return a key with a length of 32 bytes" {
+            $Key = Get-RandomAESKey
+            $Key.length | Should -Be 32
+        }
+    }
+}

src/Private/Get-TempDir.Tests.ps1

@@ -0,0 +1,44 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Get-TempDir" {
+    Context "Basic tests" {
+        It "Should not throw" {
+            { Get-TempDir } | Should -Not -Throw
+        }
+        It "Should return the correct os tmp path" {
+            $Path = Get-TempDir
+
+            if ($ENV:TRAVIS) {
+                if ($IsLinux) {
+                    $RefPath = (Resolve-Path -Path '/tmp/').Path
+                    $Path | Should -Be $RefPath
+                }
+                if ($IsMacOS) {
+                    $RefPath = (Resolve-Path -Path '/tmp/').Path
+                    $Path | Should -Be $RefPath
+                }
+            }
+            if ($Env:APPVEYOR) {
+                if (
+                    ($isWindows) -or
+                    ($PSVersionTable.PSVersion.Major -lt 6) -or
+                    ($PSVersionTable.PSEdition -eq 'Desktop')
+                ) {
+                    $RefPath = (Resolve-Path -Path $env:TEMP).Path
+                    $Path | Should -Be $RefPath
+                }
+            }
+        }
+    }
+}

src/Private/Resolve-Dependency.Tests.ps1

@@ -0,0 +1,60 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Resolve-Dependency" {
+    Context "Basic syntax check" {
+        BeforeAll {
+            Mock  Get-ModuleBase {
+                return (Join-Path -Path $PWD -ChildPath '/resources')
+            }
+            Mock Test-Module {
+                return $true
+            }
+        }
+
+        It "Test1: Should not throw" {
+            { Resolve-Dependency -Name 'foobar2000' } | Should -Not -Throw
+        }
+        It "Test2: Output type should be bool" {
+            Resolve-Dependency -Name 'foobar2000' | Should -BeOfType bool
+        }
+    }
+    Context "Enforce Error" {
+        # Return incorrect module base to enforce there is no config file.
+        Mock Get-ModuleBase {
+            if ($IsWindows) { return "C:\" }
+            elseif ($isLinux) { return "/" }
+        }
+        It "Missing dependency file should not cause an error" {
+            { Resolve-Dependency -Name 'awesome' } | Should -Not -Throw
+        }
+
+        It "Missing dependency file should return true" {
+            Resolve-Dependency -Name 'awesome' | Should -Be $true
+        }
+    }
+    Context "Testing input variations" {
+        It "Should return true if all given dependencies exist" {
+            Mock Get-ModuleBase {
+                return (Join-Path -Path $PWD -ChildPath '/resources')
+            }
+            Resolve-Dependency -Name 'Existing' | Should -Be $true
+        }
+        It "Mixed results should return false" {
+            Mock Get-ModuleBase {
+                return (Join-Path -Path $PWD -ChildPath '/resources')
+            }
+            Resolve-Dependency -Name 'PSGetMixed' | Should -Be $false
+        }
+    }
+}

src/Private/Test-CSPfxCertificate.Tests.ps1

@@ -0,0 +1,25 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Test-CSPfxCertificate" {
+    Context "Basic Tests" {
+        It "Should not Throw" {
+            {
+                Test-CSPfxCertificate -Thumbprint '12345' -StoreName My -StoreLocation CurrentUser
+            } | Should -Not -Throw
+        }
+        It "Should return false" {
+            Test-CSPfxCertificate -Thumbprint '12345' -StoreName My -StoreLocation CurrentUser | Should -Be $false
+        }
+    }
+}

src/Private/Test-Module.Tests.ps1

@@ -0,0 +1,39 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Test-ModuleName" {
+    Context "Basic input tests" {
+        It "Testing standard module should not throw" {
+            { Test-Module -Name 'PowerShellGet' } | Should -Not -Throw
+        }
+        It "Existing module should return true" {
+            Test-Module -Name 'PowerShellGet' | Should -Be $true
+        }
+    }
+    Context "Working with modules" {
+        It "Loading first module should not throw " {
+            $Mod = Get-Module -ListAvailable | Select-Object -First 1
+            { Test-Module -Name $Mod.Name } | Should -Not -Throw
+        }
+        It "Loading first module should return true" {
+            $Snap = Get-Module -ListAvailable | Select-Object -First 1
+            Test-Module -Name $Snap.Name | Should -Be $true
+        }
+        It "Not existing module should return false" {
+            Test-Module -Name 'foobar2000' | Should -Be $false
+        }
+        It "StopifFails switch should thrown an error" {
+            { Test-Module -Name 'foobar2000' -StopIfFails } | Should -Throw
+        }
+    }
+}

src/Store/Get-CredentialStore.Tests.ps1

@@ -0,0 +1,47 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Get-CredentialStore" {
+    Context "Basic logic tests" {
+        It "Read CS without params" {
+            $TestCredentialStore = './resources/cs/CredentialStore.json'
+            $TestPfxCert = './resources/cs/PSCredentialStore.pfx'
+            if (! (Test-Path -Path (Get-DefaultCredentialStorePath)) ) {
+                { New-CredentialStore -Force } | Should -Not -Throw
+            }
+            { Get-CredentialStore } | Should -Not -Throw
+        }
+        It "Read Credential Store with testing data" {
+            $TestCredentialStore = './resources/cs/CredentialStore.json'
+            $TestPfxCert = './resources/cs/PSCredentialStore.pfx'
+            {
+                Use-CSCertificate -Shared -CredentialStore $TestCredentialStore -Path $TestPfxCert
+            } | Should -Not -Throw
+            { Get-CredentialStore -Shared -Path $TestCredentialStore } | Should -Not -Throw
+        }
+        It "Test3: Not existing path should return false" {
+            {
+                Get-CredentialStore -Shared -Path './CredentialStore.json'
+            } | Should -Throw "Could not find the CredentialStore."
+        }
+    }
+    Context "Testing invalid json data" {
+        It "Should throw with invalid CredentialStore" {
+            $BrokenCS = './resources/cs/Broken_CS.json'
+            Write-Verbose -Message ('BrokenCS Path: {0}' -f $BrokenCS) -Verbose
+            {
+                Get-CredentialStore -Path -Shared $BrokenCS
+            } | Should -Throw
+        }
+    }
+}

src/Store/New-CredentialStore.Tests.ps1

@@ -0,0 +1,141 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+
+    # Backup existing credential stores
+    $VerbosePreference = "Continue"
+    Write-Verbose "Backup private Credential Store..."
+    $CSPath = Get-DefaultCredentialStorePath
+    $BackupFile = "{0}.back" -f $CSPath
+    if (Test-Path -Path $CSPath) {
+        Move-Item -Path $CSPath -Destination $BackupFile
+    }
+    Write-Verbose "Backup shared CredentialStore..."
+    $CSShared = Get-DefaultCredentialStorePath -Shared
+    $BackupSharedFile = "{0}.back" -f $CSShared
+    if (Test-Path -Path $CSShared) {
+        Move-Item -Path $CSShared -Destination $BackupSharedFile
+    }
+    Write-Verbose "Remove old CredentialStore in Temp dir"
+    $CSTemp = Join-Path -Path (Get-TempDir) -ChildPath '/CredentialStore.json'
+    if (Test-Path -Path $CSTemp) {
+        Remove-Item -Path $CSTemp
+    }
+    $VerbosePreference = "SilentlyContinue"
+}
+
+Describe "New-CredentialStore" {
+    Context "Private CS tests" {
+        It "Create new private CredentialStore" {
+            $pCS = Get-DefaultCredentialStorePath
+            { New-CredentialStore -Confirm:$false -Force } | Should -Not -Throw
+            $result = Test-Path -Path $pCS
+            $CS = Get-Content -Path $pCS -Raw | ConvertFrom-Json
+            ($result -eq $true) -and ($CS.Type -eq "Private") | Should -Be $true
+        }
+        It "Try to override private Store" {
+            { New-CredentialStore -Confirm:$false } | Should -Throw
+        }
+        It "Reset existing Credential Store" {
+            $pCS = Get-DefaultCredentialStorePath
+            $now = Get-Date
+            $CS = Get-Content -Path $pCS -Raw | ConvertFrom-Json
+            $CSCreation = [DateTime]$CS.Created
+            New-CredentialStore -Confirm:$false -Force
+            $now -gt $csCreation | Should -Be $true
+        }
+    }
+    Context "Shared CS tests" {
+        It "Create a new Shared Credential Store" {
+            $sCS = Get-DefaultCredentialStorePath -Shared
+            { New-CredentialStore -Confirm:$false -Shared } | Should -Not -Throw
+            Test-Path -Path $sCS | Should -Be $true
+        }
+        It "Try to override existing shared CS" {
+            { New-CredentialStore -Shared -Confirm:$false } | Should -Throw
+        }
+        It "Reset shared CredentialStore" {
+            $sCS = Get-DefaultCredentialStorePath -Shared
+            $now = Get-Date
+            $CS = Get-Content -Path $sCS -Raw | ConvertFrom-Json
+            $CSCreation = [DateTime]$CS.Created
+            New-CredentialStore -Force -Shared -Confirm:$false
+            $now -gt $csCreation | Should -Be $true
+        }
+    }
+    Context "Custom Shared CS tests" {
+        It "Create new custom shared" {
+            $cCS = Join-Path -Path (Get-TempDir) -ChildPath "CredentialStore.json"
+            { New-CredentialStore -Path $cCS -Shared -Confirm:$false -SkipPFXCertCreation } | Should -Not -Throw
+        }
+        It "Try to override exiting one" {
+            $cCS = Join-Path -Path (Get-TempDir) -ChildPath "CredentialStore.json"
+            { New-CredentialStore -Path $cCS -Shared -Confirm:$false } | Should -Throw
+        }
+        It "Reset existing custom CredentialStore" {
+            $cCS = Join-Path -Path (Get-TempDir) -ChildPath "CredentialStore.json"
+            { New-CredentialStore -Path $cCS -Shared -Force -Confirm:$false } | Should -Not -Throw
+        }
+    }
+    Context "Test exception handling" {
+        Mock Out-File { throw "foobar exception" }
+        It "JSON Conversion should fail and throw" {
+            {
+                New-CredentialStore -Path (
+                    Join-Path -Path (Get-TempDir) -ChildPath '/dummy.json'
+                ) -Shared -Confirm:$false
+            } | Should -Throw
+        }
+    }
+    Context "Tests for Windows certificate store" {
+        It "Create new private store and skip certificate linking" {
+            { New-CredentialStore -UseCertStore -Force } | Should -Not -Throw
+            $CS = Get-CredentialStore
+            $CS.PfxCertificate | Should -Be $null
+            $CS.Thumbprint | Should -Not -Be $null
+            $res = Test-CSCertificate -Type Private
+            #Write-Verbose -Message ('res: {0}' -f $res) -Verbose
+            $res | Should -Be $true
+
+        }
+        It "Create new shared store and skipt certificate linking" {
+            { New-CredentialStore -Shared -UseCertStore -Force } | Should -Not -Throw
+            $CS = Get-CredentialStore -Shared
+            $CS.PfxCertificate | Should -Be $null
+            $CS.Thumbprint | Should -Not -Be $null
+            $res = Test-CSCertificate -Type Shared
+            #Write-Verbose -Message ('res: {0}' -f $res) -Verbose
+            $res | Should -Be $true
+        }
+    }
+}
+
+AfterAll {
+    # Cleanup test stores and restore existing ones.
+    $VerbosePreference = "Continue"
+    Write-Verbose "Restoring private CredentialStore"
+    If (Test-Path -Path $BackupFile) {
+        If (Test-Path -Path $CSPath) {
+            Remove-Item -Path $CSPath
+            Move-Item -Path $BackupFile -Destination $CSPath
+        }
+    }
+
+    Write-Verbose "Restoring shared CredentialStore"
+    If (Test-Path -Path $BackupSharedFile) {
+        If (Test-Path -Path $CSShared) {
+            Remove-Item -Path $CSShared
+            Move-Item -Path $BackupSharedFile -Destination $CSShared
+        }
+    }
+    $VerbosePreference = "SilentlyContinue"
+
+}

src/Store/Test-CredentialStore.Tests.ps1

@@ -0,0 +1,48 @@
+BeforeAll {
+    $ManifestFile = (Get-Item -Path "./src/*.psd1").FullName
+    Import-Module $ManifestFile -Force
+
+    $PrivateFunctions = (Get-ChildItem -Path "./src/Private/*.ps1" | Where-Object {
+            $_.BaseName -notmatch '.Tests'
+        }
+    ).FullName
+    foreach ( $func in $PrivateFunctions) {
+        . $func
+    }
+}
+
+Describe "Test-CredentialStore" {
+    Context "Basic logic tests" {
+        It "Should Not Throw" {
+            $TestCredentialStore = './resources/cs/CredentialStore.json'
+            { Test-CredentialStore -Shared -Path $TestCredentialStore } | Should -Not -Throw
+        }
+        It "Read valid CredentialStore" {
+            $TestCredentialStore = './resources/cs/CredentialStore.json'
+            $res = Test-CredentialStore -Shared -Path $TestCredentialStore
+            $res | Should -Be $true
+        }
+        It "Read a broken CredentialStore" -Skip {
+            $BrokenCS = './resources/cs/Broken_CS.json'
+            $oWarningPreference = $WarningPreference
+            $WarningPreference = 'SilentlyContinue'
+            $res = Test-CredentialStore -Shared -Path $BrokenCS
+            $res | Should -Be $false
+            $WarningPreference = $oWarningPreference
+        }
+        It "Not existing path should return false" {
+            if ($isWindows -or ($PSVersionTable.PSVersion.Major -eq 5)) {
+                Test-CredentialStore -Shared -Path 'C:\foobar\CredentialStore.json' | Should -Be $false
+            }
+            elseif ($isWindows -or $IsMacOS) {
+                Test-CredentialStore -Shared -Path '/var/opt/foo.json' | Should -Be $false
+            }
+        }
+        It "testing private CredentialStore path" {
+            if (Test-Path -Path (Get-DefaultCredentialStorePath)) {
+                Remove-Item -Path (Get-DefaultCredentialStorePath)
+            }
+            Test-CredentialStore | Should -Be $false
+        }
+    }
+}