describe Object do
  describe "#deep_symbolize" do
    subject { obj.deep_symbolize }

    context "when object is an Hash" do
      let(:obj) { { "key1" => "value1", key2: "value2" } }
      it { should eq(key1: "value1", key2: "value2") }

      context "with inner Hashes" do
        before { obj["key2"] = { "key3" => { "key4" => "value4" } } }
        it { should eq(key1: "value1", key2: { key3: { key4: "value4" } }) }
      end
    end

    context "when object is an Array" do
      let(:obj) { ["value1"] }
      it { should eq obj }

      context "with inner Hashes" do
        let(:obj) { [{ "key1" => "value1" }, { "key2" => "value2" }] }
        it { should eq([{ key1: "value1" }, { key2: "value2" }]) }
      end
    end

    context "when object is something else" do
      let(:obj) { "value1" }
      it { should eq obj }
    end
  end

  describe "#validate_structure!" do
    subject { obj.validate_structure!(structure) }

    context "when object type differs of the structure type" do
      let(:obj) { "a string" }
      let(:structure) { { type: Integer } }
      it { expect { subject }.to raise_error /expected Integer, got String/i }
    end

    context "when object is a Nil" do
      let(:obj) { nil }
      let(:structure) { { type: Integer } }
      it { expect { subject }.to raise_error /expected Integer, got NilClass/i }

      context "but is also optional" do
        before { structure[:optional] = true }
        it { expect { subject }.not_to raise_error }
      end
    end

    context "when object is an Array" do
      let(:obj) { %w[elem1 elem2] }
      let(:structure) { { type: Array } }
      it { expect { subject }.not_to raise_error }

      context "given an element structure" do
        before { structure[:elements] = { type: String } }
        it { expect { subject }.not_to raise_error }

        context "which is not respected" do
          before { structure[:elements] = { type: Integer } }
          it { expect { subject }.to raise_error /expected Integer, got String/i }
        end
      end
    end

    context "when object is an Hash" do
      let(:obj) { { key1: "value1", key2: "value2", key3: "value3" } }
      let(:structure) { { type: Hash } }
      it { expect { subject }.not_to raise_error }

      context "when given an element structure" do
        let(:structure) { { type: Hash, elements: { key1: { type: String }, key2: { type: String }, key3: { type: String } } } }
        it { expect { subject }.not_to raise_error }

        context "which is not respected" do
          before { obj[:key2] = {} }
          it { expect { subject }.to raise_error /expected String, got Hash/i }
        end

        context "when missing keys" do
          before do
            obj.delete(:key1)
            obj.delete(:key3)
          end
          it { expect { subject }.to raise_error /missing keys: key1, key3/i }

          context "which are optional" do
            before do
              structure[:elements][:key1][:optional] = true
              structure[:elements][:key3][:optional] = true
            end
            it { expect { subject }.not_to raise_error }
          end
        end
      end
    end
  end
end