big_ml 0.1.2 → 0.1.3

data/spec/integration/evaluation_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe BigML::Evaluation, :vcr do
+
+  before do
+    BigML::Source.delete_all
+    BigML::Dataset.delete_all
+    BigML::Model.delete_all
+    BigML::Evaluation.delete_all
+  end
+
+  describe "no evaluation" do
+    describe ".all" do
+      it "must be empty" do
+        expect(BigML::Evaluation.all).to eq([])
+      end
+    end
+  end
+
+  describe "one evaluation" do
+    let(:source) { BigML::Source.create 'spec/fixtures/iris.csv' }
+    let(:dataset) { BigML::Dataset.create source.wait_for_ready.resource }
+    let(:model) { BigML::Model.create dataset.wait_for_ready.resource }
+    let!(:evaluation) { BigML::Evaluation.create model.wait_for_ready.resource, dataset.wait_for_ready.resource }
+
+    it "was created successfully" do
+      expect(evaluation.code).to eq(201)
+    end
+
+    it "must have only one item" do 
+      expect(BigML::Evaluation.all.length).to eq(1)
+    end
+
+    it "must have the same name" do
+      expect(BigML::Evaluation.all.first.name).to match(/^Evaluation of iris/)
+    end
+
+    it "must be able to be find using the reference" do
+      expect(BigML::Evaluation.find(evaluation.id).id).to eq(evaluation.id)
+    end
+
+    it "must be able to update the name" do
+      expect(BigML::Evaluation.update(evaluation.wait_for_ready.id, { :name => 'foo name' }).code).to eq(202)
+      expect(BigML::Evaluation.find(evaluation.id).name).to eq('foo name')
+    end
+
+    it "must be able to update the name from the instance" do
+      expect(evaluation.wait_for_ready.update(name: 'foo name').code).to eq(202)
+      expect(BigML::Evaluation.find(evaluation.id).name).to eq('foo name')
+    end
+
+    it "must be able to remove the evaluation" do
+      BigML::Evaluation.delete evaluation.id
+      expect(BigML::Evaluation.find evaluation.id).to be_nil
+      expect(BigML::Evaluation.all.length).to eq(0)
+    end
+
+    it "must be able to be deleted using the destroy method" do
+      evaluation_id = evaluation.id
+      evaluation.destroy
+      expect(BigML::Evaluation.find evaluation_id).to be_nil
+    end
+  end
+end

data/spec/integration/model_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe BigML::Model, :vcr do
 
-  before(:each) do
+  before do
     BigML::Source.delete_all
     BigML::Dataset.delete_all
     BigML::Model.delete_all
@@ -11,60 +11,58 @@ describe BigML::Model, :vcr do
   describe "no model" do
     describe ".all" do
       it "must be empty" do
-        BigML::Model.all.should == []
+        expect(BigML::Model.all).to eq([])
       end
     end
   end
 
   describe "one model" do
-    before do
-      @source = BigML::Source.create("spec/fixtures/iris.csv")
-      @dataset = BigML::Dataset.create(@source.resource)
-      @model = BigML::Model.create(@dataset.resource)
-    end
+    let(:source) { BigML::Source.create 'spec/fixtures/iris.csv' }
+    let(:dataset) { BigML::Dataset.create source.resource }
+    let(:model) { BigML::Model.create dataset.resource }
 
     it "was created successfully" do
-      @model.code.should == 201
+      expect(model.code).to eq(201)
     end
 
-    it "must have only one item" do 
-      BigML::Model.all.should have(1).models
+    it "must have only one item" do
+      expect(BigML::Model.all.length).to eq(1)
     end
 
     it "must have the same size" do
-      BigML::Model.all.first.size.should == 4608
+      expect(BigML::Model.all.first.size).to eq(4608)
     end
 
     it "must be able to be find using the reference" do
-      BigML::Model.find(@model.id) == @model
+      expect(BigML::Model.find(model.id).id).to eq(model.id)
     end
 
     it "must be able to update the name" do
-      BigML::Model.update(@model.id, { :name => 'foo name' }).code.should == 202
-      BigML::Model.find(@model.id).name.should == 'foo name'
+      expect(BigML::Model.update(model.id, { name: 'foo name' }).code).to eq(202)
+      expect(BigML::Model.find(model.id).name).to eq('foo name')
     end
 
     it "must be able to update the name from the instance" do
-      @model.update( :name => 'foo name' ).code.should == 202
-      BigML::Model.find(@model.id).name.should == 'foo name'
+      expect(model.update(name: 'foo name').code).to eq(202)
+      expect(BigML::Model.find(model.id).name).to eq('foo name')
     end
 
     it "must be able to remove the model" do
-      BigML::Model.delete(@model.id)
-      BigML::Model.find(@model.id).should be_nil
-      BigML::Model.all.should have(0).models
+      BigML::Model.delete model.id
+      expect(BigML::Model.find model.id).to be_nil
+      expect(BigML::Model.all.length).to eq(0)
     end
 
     it "must be able to be deleted using the destroy method" do
-      model_id = @model.id
-      @model.destroy
-      BigML::Model.find(model_id).should be_nil
+      model_id = model.id
+      model.destroy
+      expect(BigML::Model.find model_id).to be_nil
     end
 
     it "can be converted in a prediction" do
-      prediction = @model.to_prediction(:input_data => { "000001" => 3 })
-      prediction.instance_of?(BigML::Prediction).should be_true
-      prediction.code.should == 201
+      prediction = model.to_prediction(input_data: { "000001" => 3 })
+      expect(prediction).to be_instance_of(BigML::Prediction)
+      expect(prediction.code).to eq(201)
     end
   end
 end

data/spec/integration/prediction_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe BigML::Prediction, :vcr do
 
-  before(:each) do
+  before do
     BigML::Source.delete_all
     BigML::Dataset.delete_all
     BigML::Model.delete_all
@@ -12,55 +12,53 @@ describe BigML::Prediction, :vcr do
   describe "no prediction" do
     describe ".all" do
       it "must be empty" do
-        BigML::Prediction.all.should == []
+        expect(BigML::Prediction.all).to eq([])
       end
     end
   end
 
   describe "one prediction" do
-    before do
-      @source = BigML::Source.create("spec/fixtures/iris.csv")
-      @dataset = BigML::Dataset.create(@source.resource)
-      @model = BigML::Model.create(@dataset.resource)
-      @prediction = BigML::Prediction.create(@model.resource, { :input_data => { "000001" => 3 }})
-    end
+    let(:source) { BigML::Source.create 'spec/fixtures/iris.csv' }
+    let(:dataset) { BigML::Dataset.create source.resource }
+    let(:model) { BigML::Model.create dataset.resource }
+    let(:prediction) { BigML::Prediction.create model.resource, { input_data: { "000001" => 3 }} }
 
     it "was created successfully" do
-      @prediction.code.should == 201
+      expect(prediction.code).to eq(201)
     end
 
     it "must have only one item" do 
-      BigML::Prediction.all.should have(1).predictions
+      expect(BigML::Prediction.all.length).to eq(1)
     end
 
     it "must have the same name" do
-      BigML::Prediction.all.first.name.should == "Prediction for species"
+      expect(BigML::Prediction.all.first.name).to eq("Prediction for species")
     end
 
     it "must be able to be find using the reference" do
-      BigML::Prediction.find(@prediction.id) == @prediction
+      expect(BigML::Prediction.find(prediction.id).id).to eq(prediction.id)
     end
 
     it "must be able to update the name" do
-      BigML::Prediction.update(@prediction.id, { :name => 'foo name' }).code.should == 202
-      BigML::Prediction.find(@prediction.id).name.should == 'foo name'
+      expect(BigML::Prediction.update(prediction.id, { :name => 'foo name' }).code).to eq(202)
+      expect(BigML::Prediction.find(prediction.id).name).to eq('foo name')
     end
 
     it "must be able to update the name from the instance" do
-      @prediction.update( :name => 'foo name' ).code.should == 202
-      BigML::Prediction.find(@prediction.id).name.should == 'foo name'
+      expect(prediction.update(name: 'foo name').code).to eq(202)
+      expect(BigML::Prediction.find(prediction.id).name).to eq('foo name')
     end
 
     it "must be able to remove the prediction" do
-      BigML::Prediction.delete(@prediction.id)
-      BigML::Prediction.find(@prediction.id).should be_nil
-      BigML::Prediction.all.should have(0).predictions
+      BigML::Prediction.delete prediction.id
+      expect(BigML::Prediction.find prediction.id).to be_nil
+      expect(BigML::Prediction.all.length).to eq(0)
     end
 
     it "must be able to be deleted using the destroy method" do
-      prediction_id = @prediction.id
-      @prediction.destroy
-      BigML::Prediction.find(prediction_id).should be_nil
+      prediction_id = prediction.id
+      prediction.destroy
+      expect(BigML::Prediction.find prediction_id).to be_nil
     end
   end
 end

data/spec/integration/source_spec.rb

@@ -2,67 +2,65 @@ require "spec_helper"
 
 describe BigML::Source, :vcr do
 
-  before(:each) do
+  before do
     BigML::Source.delete_all
   end
 
   describe "no source" do
     describe ".all" do
       it "must be empty" do
-        BigML::Source.all.should == []
+        expect(BigML::Source.all).to eq([])
       end
     end
   end
 
   describe "one source" do
-    before do
-      @source = BigML::Source.create("spec/fixtures/iris.csv")
-    end
+    let(:source) { BigML::Source.create 'spec/fixtures/iris.csv' }
 
     it "was created successfully" do
-      @source.code.should == 201
+      expect(source.code).to eq(201)
     end
 
     it "must have only one item" do 
-      BigML::Source.all.should have(1).sources
+      expect(BigML::Source.all.length).to eq(1)
     end
 
     it "must have the same file_name" do
-      BigML::Source.all.first.file_name.should == "iris.csv"
+      expect(BigML::Source.all.first.file_name).to eq("iris.csv")
     end
 
     it "must be able to be find using the reference" do
-      BigML::Source.find(@source.id) == @source
+      expect(BigML::Source.find(source.id).id).to eq(source.id)
     end
 
     it "must be able to update the name" do
-      BigML::Source.find(@source.id).name.should == 'iris.csv'
-      BigML::Source.update(@source.id, { :name => 'new name' }).code.should == 202
-      BigML::Source.find(@source.id).name.should == 'new name'
+      expect(BigML::Source.find(source.id).name).to eq('iris.csv')
+      expect(BigML::Source.update(source.id, { name: 'new name' }).code).to eq(202)
+      expect(BigML::Source.find(source.id).name).to eq('new name')
     end
 
     it "must be able to update the name from the instance" do
-      BigML::Source.find(@source.id).name.should == 'iris.csv'
-      @source.update( :name => 'new name' ).code.should == 202
-      BigML::Source.find(@source.id).name.should == 'new name'
+      expect(BigML::Source.find(source.id).name).to eq('iris.csv')
+      expect(source.update(name: 'new name').code).to eq(202)
+      expect(BigML::Source.find(source.id).name).to eq('new name')
     end
 
     it "must be able to remove the source" do
-      BigML::Source.delete(@source.id)
-      BigML::Source.find(@source.id).should be_nil
-      BigML::Source.all.should have(0).sources
+      BigML::Source.delete source.id
+      expect(BigML::Source.find source.id).to be_nil
+      expect(BigML::Source.all.length).to eq(0)
     end
 
     it "must be able to be deleted using the destroy method" do
-      source_id = @source.id
-      @source.destroy
-      BigML::Source.find(source_id).should be_nil
+      source_id = source.id
+      source.destroy
+      expect(BigML::Source.find source_id).to be_nil
     end
 
     it "can be converted in a dataset" do
-      dataset = @source.to_dataset
-      dataset.instance_of?(BigML::Dataset).should be_true
-      dataset.code.should == 201
+      dataset = source.to_dataset
+      expect(dataset).to be_instance_of(BigML::Dataset)
+      expect(dataset.code).to eq(201)
     end
   end
 end

data/spec/spec_helper.rb

@@ -16,7 +16,8 @@ VCR.configure do |c|
   c.filter_sensitive_data('<API_KEY>') { BigML.api_key }
 end
 
-RSpec.configure do |c|
-  c.mock_with :rspec
-  c.treat_symbols_as_metadata_keys_with_true_values = true
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

data/spec/units/client_spec.rb

@@ -1,81 +1,113 @@
 require 'spec_helper'
 
 describe BigML::Util::Client do
-  let(:keys) {
-    BigML::Util::Config::VALID_OPTIONS_KEYS
-  }
+  let(:keys) { BigML::Util::Config::VALID_OPTIONS_KEYS }
 
   context "module configuration" do
-    before(:each) {
+    before do
       BigML.configure do |config|
         keys.each { |key| config.send("#{key}=", key) }
       end
-    }
+    end
 
     it "should inherit module configuration" do
       api = BigML::Util::Client.new
-      keys.each { |key| api.send(key).should == key }
+      keys.each { |key| expect(api.send(key)).to eq(key) }
     end
   end
 
   context "class configuration" do
-    let(:config) {
+    let(:config) do
       {
-        :username => 'user',
-        :api_key  => 'secret',
-        :dev_mode => true
+        username: 'user',
+        api_key: 'secret',
+        dev_mode: true,
+        debug: false
       }
-    }
+    end
 
     context "during initialization" do
       it "should override module configuration" do
         api = BigML::Util::Client.new(config)
-        keys.each { |key| api.send(key).should == config[key] }
+        keys.each { |key| expect(api.send(key)).to eq(config[key]) }
       end
     end
 
     context "after initilization" do
-      before(:each) {
+      before do
         BigML.configure do |config|
           keys.each { |key| config.send("#{key}=", key) }
         end
-      }
+      end
 
       it "should override module configuration" do
         api = BigML::Util::Client.new
         config.each { |key, value| api.send("#{key}=", value) }
-        keys.each { |key| api.send(key).should == config[key] }
+        keys.each { |key| expect(api.send(key)).to eq(config[key]) }
       end
     end
   end
 
   context "reset module configuration" do
-    let(:api) {
-      BigML::Util::Client.new
-    }
+    let(:api) { BigML::Util::Client.new }
 
-    before(:each) {
+    before do
       BigML.reset
-    }
+    end
 
     it "sets default username to nil" do
-      api.username.should be_nil
+      expect(api.username).to be_nil
     end
 
     it "sets default api key to nil" do
-      api.api_key.should be_nil
+      expect(api.api_key).to be_nil
     end
   end
 
-  context "environemt mode" do
+  context "environment mode" do
     it "uses production mode as default" do
-      BigML::Util::Client.base_uri.should == BigML::Util::Config::BIGML_PROD_ENDPOINT
+      expect(BigML::Util::Client.base_uri).to eq(BigML::Util::Config::BIGML_PROD_ENDPOINT)
     end
 
     it "uses development when dev_mode is enabled" do
-      BigML::Util::Client.new({:dev_mode => true})
-      BigML::Util::Client.base_uri.should == BigML::Util::Config::BIGML_DEV_ENDPOINT
+      BigML::Util::Client.new({ dev_mode: true })
+      expect(BigML::Util::Client.base_uri).to eq(BigML::Util::Config::BIGML_DEV_ENDPOINT)
     end
   end
 
+  context 'response handling', :vcr do
+    let(:client) { BigML::Util::Client.new config }
+    let(:base_config) do
+      {
+        username: 'bad',
+        api_key: 'auth',
+        dev_mode: true,
+      }
+    end
+    let(:resource) { BigML::Source }
+
+    before do
+      resource.instance_variable_set :@client, client
+    end
+
+    describe 'debug mode' do
+      let(:config) { base_config.merge debug: true}
+
+      it 'raises on bad request' do
+        expect{resource.create 'spec/fixtures/iris.csv'}.to raise_error(BigML::UnsuccessfulRequestError, /unauthorized/i)
+      end
+    end
+
+    describe 'normal mode' do
+      let(:config) { base_config.merge debug: false}
+
+      it 'does not raise on bad request' do
+        expect{resource.create 'spec/fixtures/iris.csv'}.not_to raise_error
+      end
+    end
+
+    after do
+      resource.instance_variable_set :@client, nil
+    end
+  end
 end