obvious 0.1.0 → 0.2.0

data/spec/contract_spec.rb

@@ -1,63 +0,0 @@
-require_relative 'spec_helper'
-require_relative '../lib/obvious/contract'
-
-
-describe Hash do
-  describe '#has_shape?' do
-    it 'should return true for a valid shape' do
-      expect({ id: 1 }.has_shape?(id: Integer)).to be true
-    end
-    
-    it 'should return false for an invalid shape' do
-      expect({ id: 1 }.has_shape?(id: String)).to be false
-    end
-
-    it 'should retrn the invalid field if return_field flag is set' do
-      expect({ id: 1 }.has_shape?({id: String}, true)).to eq [false, :id]
-    end
-
-    it 'should allow for nil values to be returned' do
-      expect({ id: nil }.has_shape?({id: String})).to be true
-    end 
-  end
-end
-
-class TestContract < Obvious::Contract
-  contract_for :test, {
-    input: { id: Integer },
-    output: { id: Integer, value: String }
-  }
-
-  def test input
-    { id: 1, value: 'this is a test' } 
-  end
-end
-
-describe Obvious::Contract do
-
-  describe "#call_method" do
-    it 'should return the correct output for valid input and output shapes' do
-      tc = TestContract.new
-      result = tc.test id: 1
-      expect(result).to eq id: 1, value: 'this is a test'
-    end
-  
-    it 'should raise a contract input error with bad input' do
-      tc = TestContract.new
-      expect { tc.test Hash.new }.to raise_error ContractInputError
-    end
-
-    it 'should raise a DataNotFound error if {} is returned' do
-      tc = TestContract.new
-      allow(tc).to receive(:test_alias).and_return({}) 
-      expect { tc.test id: 1 }.to raise_error DataNotFoundError
-    end
-
-    it 'should raise a contract output error if nil is returned' do
-      tc = TestContract.new
-      allow(tc).to receive(:test_alias).and_return(nil) 
-      expect { tc.test id: 1 }.to raise_error ContractOutputError
-    end
-
-  end
-end

data/spec/entity_spec.rb

@@ -1,75 +0,0 @@
-require_relative '../lib/obvious/entity'
-
-class Thing < Obvious::Entity
-  value :id, Integer 
-  value :name, String 
-end
-
-class Thing2 < Obvious::Entity
-  value :foo , String
-
-  validation :something, Proc.new {
-    if foo != "hello world"
-      msg = "Validation Error: Invalid value for foo, should be 'hello world'"
-      raise Obvious::ValidationError.new msg 
-    end
-  }
-
-  def modify_foo 
-    @values[:foo] = 100
-  end
-
-end
-
-class Thing3 < Obvious::Entity
-  value :foo , String
-
-  validation :something, Proc.new {
-    @values[:foo] = 12
-  }
-
-end
-
-# To test the entity, we are going to use classes that inherit from it instead
-# of poking at it directly. In this case, I think that makes the most sense.
-describe Thing do
-  it 'should create a valid object with valid input' do
-    input = { name: 'Thing', id: 1 }
-    t = Thing.new input
-    expect(t.name).to eq 'Thing'
-    expect(t.id).to eq 1
-  end
-
-  it 'should raise an error with invalid input types' do
-    input = { name: nil, id: nil }
-    expect { Thing.new input }.to raise_error Obvious::TypeError
-  end
-
-  it 'should raise an error with extra fields in input' do
-    input = { name: 'Thing', id: 1, extra: 'should explode' }
-    expect { Thing.new input }.to raise_error Obvious::ShapeError
-  end
-
-  it 'should raise an error when a method tries to modify a value' do
-    t = Thing2.new foo: 'hello world'
-    expect { t.modify_foo }.to raise_error RuntimeError
-  end
-
-  describe '#to_hash' do
-    it 'should return a hash representation of the object' do
-      input = { name: 'Thing', id: 1 }
-      t = Thing.new input
-      expect(t.to_hash).to eq input
-    end
-  end
-
-  describe 'validation' do
-    it 'should raise a validation error on a failed validation' do
-      expect { Thing2.new foo: 'not valid I promise!' }.to raise_error Obvious::ValidationError
-    end
-    
-    it 'should raise an error when trying to modify an object in a validation' do
-      expect { Thing3.new foo: 'hello world' }.to raise_error RuntimeError
-    end
-  end
-end

data/spec/generators/descriptor_spec.rb

@@ -1,34 +0,0 @@
-require_relative '../../lib/generators/descriptor'
-
-require File.expand_path('spec/spec_helper')
-
-module Obvious
-  module Generators
-    describe Descriptor do
-      subject {Descriptor.new(yaml_file)}
-
-      describe "#to_file" do
-       
-        context "when the descriptor is empty" do
-          let( :yaml_file ) { {} }
-
-          it "should raise a meaningful error" do
-           expect {subject.to_file}.to raise_error(InvalidDescriptorError)
-          end
-        end
-
-        ["Action", "Code", "Description"].each do |section|
-          context "when the '#{section}' section is omitted" do
-            let( :yaml_file ) {
-              {"Action" => "Jackson", "Description" => "This is something"}.delete(section)
-            }
-
-            it "should raise a meaningful error" do
-              expect {subject.to_file}.to raise_error(InvalidDescriptorError)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/obj_spec.rb

@@ -1,64 +0,0 @@
-require_relative '../lib/obvious/obj'
-
-class TestObj
-  include Obvious::Obj 
-
-  def initialize 
-    @local = 'set!'
-  end
-
-  define :defined_method, with_foo: [:foo, String], also_bar: [:bar, Integer] do |input|
-    input
-  end
-
-  define :defined_local do |input|
-    @local
-  end
-
-end
-
-describe Obvious::Obj do
-
-  before do
-    @test = TestObj.new
-  end
-
-  describe 'self.define' do
-    it 'should do the right thing with correct input' do
-      result = @test.defined_method with_foo: 'hello', also_bar: 12
-      expect(result).to eq foo: 'hello', bar: 12
-    end
-
-    it 'should have access to instance variables' do
-      result = @test.defined_local
-      expect(result).to eq 'set!' 
-    end
-
-    it 'should raise an error for missing parameters' do
-      expect { @test.defined_method with_foo: 'hello' }.to raise_error { |error| 
-        expect(error).to be_a ArgumentError
-        expect(error.message).to eq 'missing input field also_bar'
-      }
-    end
-
-    it 'should raise an error for extra parameters' do
-      expect { @test.defined_method with_foo: 'hello', also_bar: 12, and_extra: 'this is extra!' }.to raise_error { |error|
-        expect(error).to be_a ArgumentError
-        expect(error.message).to eq 'invalid input field and_extra'
-      }
-    end
-
-    it 'should raise an error for invalid types' do
-      expect { @test.defined_method with_foo: 1, also_bar: 12 }.to raise_error { |error|
-        expect(error).to be_a ArgumentError 
-        expect(error.message).to eq 'invalid type for with_foo expected String'
-      }
-
-      expect {@test.defined_method with_foo: 'hello', also_bar: nil }.to raise_error { |error|
-        expect(error).to be_a ArgumentError
-        expect(error.message).to eq 'invalid type for also_bar expected Integer'
-      } 
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-RSpec.configure do |c|
-  c.mock_with :rspec 
-end