 
                 context("when all of the dictionary values can be cast to NSArrays") {
                     it("should return the correctly converted objects") {
-                        let field = ModelWithDictionaryProperty.Key.convertibleDictionaryProperty
                         let value: NSDictionary = ["" : [""]]
                         let dict: NSDictionary = [field.stringValue : value]
                         let mapper = KeyedMapper(JSON: dict, type: ModelWithDictionaryProperty.self)

class KeyedMapper_ConvertibleSpec: QuickSpec {
    override func spec() {
        describe("from<T: Convertible> -> T") {
            context("when the fromMap implementation throws an error") {
                it("should throw an error") {
                    let expectedValue = 2
                    let dict: NSDictionary = ["convertibleProperty" : expectedValue]
                    let mapper = KeyedMapper(JSON: dict, type: Model.self)
                    
                    do {
                        let _: ConvertibleObject = try mapper.from(.convertibleProperty)
                    } catch let error as MapperError {
                        expect(error) == MapperError.convertible(value: expectedValue, expectedType: String.self)
                    } catch {

            context("when the value can be casted to an array of Any") {
                it("should map correctly") {
                    let expectedValue = [""]
                    let dict: NSDictionary = [field.stringValue : expectedValue]
                    let mapper = KeyedMapper(JSON: dict, type: ModelWithArrayProperty.self)
                    let convertibleArray: [ConvertibleObject] = try! mapper.from(field)
                    
                    expect(convertibleArray.count) == expectedValue.count
                }
