MajorDiatonicHarmonySpec.swift

import Foundation
import Quick
import Nimble
@testable import Notes

class MajorDiatonicHarmonySpec: QuickSpec {
    
    override func spec() {
        
        describe("Major Diatonic Harmony") {
           
            context("C natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .C, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .C, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .F, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .G, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .B, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("G natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .G, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .G, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .C, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .D, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .F, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("D natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .D, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .D, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
                        MajorSeventhChord(key: Note(name: .G, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .A, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .C, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("A natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .A, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .A, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
                        MajorSeventhChord(key: Note(name: .D, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .E, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
                        HalfDiminishedSeventhChord(key: Note(name: .G, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("E natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .E, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .E, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
                        MajorSeventhChord(key: Note(name: .A, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .B, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
                        HalfDiminishedSeventhChord(key: Note(name: .D, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("B natural") {
                
                it("should have the expected chords") {
                    let key = Note(name: .B, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .B, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .D, intonation: .sharp)),
                        MajorSeventhChord(key: Note(name: .E, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .F, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
                        HalfDiminishedSeventhChord(key: Note(name: .A, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("F sharp") {
                
                it("should have the expected chords") {
                    let key = Note(name: .F, intonation: .sharp)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .F, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .A, intonation: .sharp)),
                        MajorSeventhChord(key: Note(name: .B, intonation: .natural)),
                        DominantSeventhChord(key: Note(name: .C, intonation: .sharp)),
                        MinorSeventhChord(key: Note(name: .D, intonation: .sharp)),
                        HalfDiminishedSeventhChord(key: Note(name: .E, intonation: .sharp))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("G flat") {
                
                it("should have the expected chords") {
                    let key = Note(name: .G, intonation: .flat)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .G, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .A, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
                        MajorSeventhChord(key: Note(name: .C, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .D, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .E, intonation: .flat)),
                        HalfDiminishedSeventhChord(key: Note(name: .F, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("D flat") {
                
                it("should have the expected chords") {
                    let key = Note(name: .D, intonation: .flat)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .D, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .E, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .G, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .A, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
                        HalfDiminishedSeventhChord(key: Note(name: .C, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            
            
            context("A flat") {
                
                it("should have the expected chords") {
                    let key = Note(name: .A, intonation: .flat)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .A, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .D, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .E, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .G, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            context("E flat") {
                
                it("should have the expected chords") {
                    let key = Note(name: .E, intonation: .flat)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .E, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .A, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .B, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .D, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            
            
            context("B flat") {
                it("should have the expected chords") {
                    let key = Note(name: .B, intonation: .flat)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .B, intonation: .flat)),
                        MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .E, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .F, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .A, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            
            
            context("F natural") {
                it("should have the expected chords") {
                    let key = Note(name: .F, intonation: .natural)
                    let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
                    let expectedChords: [Chord] = [
                        MajorSeventhChord(key: Note(name: .F, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
                        MajorSeventhChord(key: Note(name: .B, intonation: .flat)),
                        DominantSeventhChord(key: Note(name: .C, intonation: .natural)),
                        MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
                        HalfDiminishedSeventhChord(key: Note(name: .E, intonation: .natural))
                    ]
                    
                    expect(chords.count).to(equal(expectedChords.count))
                    
                    let chordNames = chords.map{$0.fullName()}
                    let expectedChordNames = expectedChords.map{$0.fullName()}
                    
                    expect(chordNames).to(equal(expectedChordNames))
                }
            }
            
            
            
        }
    }
    
}