blue_state_digital 0.6.0

data/spec/blue_state_digital/contribution_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe BlueStateDigital::Contribution do
+  let(:attributes) { 
+    {
+      external_id:      'GUID_1234',
+      firstname:        'carlos',
+      lastname:         'the jackal',
+      transaction_amt:  1.0,
+      transaction_dt:   '2012-12-31 23:59:59',
+      cc_type_cd:       'vs'
+    } 
+  }
+
+  it { is_expected.to have_fields(
+    :external_id,
+    :prefix,:firstname,:middlename,:lastname,:suffix,
+    :transaction_dt,:transaction_amt,:cc_type_cd,:gateway_transaction_id,
+    :contribution_page_id,:stg_contribution_recurring_id,:contribution_page_slug,
+    :outreach_page_id,:source,:opt_compliance,
+    :addr1,:addr2,:city,:state_cd,:zip,:country,
+    :phone,:email,
+    :employer,:occupation,
+    :custom_fields
+    ) }
+
+  describe 'as_json' do
+    let(:connection) { double }
+
+    it 'should include contribution_page_id and contribution_page_slug if they are set' do
+      contribution = BlueStateDigital::Contribution.new(attributes.merge({ connection: connection, contribution_page_slug: 'donate-here-12', contribution_page_id: 4 }))
+      expect(contribution.as_json).to include('contribution_page_id')
+      expect(contribution.as_json).to include('contribution_page_slug')
+    end
+
+    it 'should not include contribution_page_id and contribution_page_slug if they are not set' do
+      contribution = BlueStateDigital::Contribution.new(attributes.merge({ connection: connection }))
+      expect(contribution.as_json).not_to include('contribution_page_id')
+      expect(contribution.as_json).not_to include('contribution_page_slug')
+    end
+  end
+
+  describe 'save' do
+    let(:connection) { double }
+    let(:contribution) { BlueStateDigital::Contribution.new(attributes.merge({ connection: connection })) }
+
+    before :each do
+      expect(connection)
+        .to receive(:perform_request)
+        .with(
+          '/contribution/add_external_contribution', 
+          {accept: 'application/json'}, 
+          'POST',
+          [contribution].to_json
+        )
+        .and_return(response)
+    end
+
+    context 'successful' do
+      let(:response) {
+        { 
+          'summary'=> { 
+            'sucesses'=>   1, 
+            'failures'=>     0, 
+            'missing_ids'=>  0 
+          }, 
+          'errors'=> {
+          } 
+        }.to_json
+      }
+
+      it "should perform API request" do
+        saved_contribution = contribution.save
+        expect(saved_contribution).not_to be_nil
+      end
+    end
+
+    context 'failure' do
+      context 'bad request' do
+        let(:response) { 'Method add_external_contribution expects a JSON array.' }
+        it "should raise error" do
+          expect { contribution.save }.to raise_error(
+            BlueStateDigital::Contribution::ContributionSaveFailureException,
+            /Method add_external_contribution expects a JSON array/m
+          )
+        end
+      end   
+      context 'missing ID' do
+        let(:response) {
+          { 
+            'summary'=> { 
+              'sucesses'=>  0, 
+              'failures'=>    0, 
+              'missing_ids'=>  1
+            }, 
+            'errors'=>{
+            } 
+          }.to_json
+        }
+        it "should raise error" do
+          expect { contribution.save }.to raise_error(
+            BlueStateDigital::Contribution::ContributionExternalIdMissingException
+          )
+        end
+      end
+      context 'validation errors' do
+        let(:response) {
+          { 
+            'summary'=> { 
+              'sucesses'=>  0, 
+              'failures'=>    1, 
+              'missing_ids'=> 0
+            }, 
+            'errors'=>{ 
+              'UNIQUE_ID_1234567890'=>
+                [
+                  'Parameter source is expected to be a list of strings', 
+                  'Parameter email does not appear to be a valid email address.'
+                ] 
+              }
+          }.to_json
+        }
+        it "should raise error" do
+          expect { contribution.save }.to raise_error(
+            BlueStateDigital::Contribution::ContributionSaveValidationException,
+            /Error for Contribution.ID. UNIQUE_ID_1234567890.. Parameter source is expected to be a list of strings, Parameter email does not appear to be a valid email address/m
+            )
+        end
+      end
+    end
+  end
+end

data/spec/blue_state_digital/dataset_map_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe BlueStateDigital::DatasetMap do
+
+  let(:connection) { double }
+  let(:dataset_map_attributes) do
+    {
+    }
+  end
+  subject { BlueStateDigital::DatasetMap.new(dataset_map_attributes.merge({connection: connection}))}
+
+  describe "new" do
+    it "should accept dataset_map params" do
+      dataset = BlueStateDigital::Dataset.new(dataset_map_attributes)
+      dataset_map_attributes.each do |k,v|
+        expect(dataset.send(k)).to eq(v)
+      end
+    end
+  end
+
+  describe "save" do
+    context "validations" do
+      it "should not error if there is no data" do
+        expect(subject.data).to be_blank
+        expect(subject).to be_valid
+      end
+      it "should error if there is data but no data header" do
+        subject.add_data_row([1])
+        expect(subject).not_to be_valid
+        expect(subject.errors.full_messages).to eq(["data_header is missing"])
+      end
+    end
+    context "csv upload" do
+      let(:header) { ['a','b','c','d'] }
+      let(:row1) { ['1','2','3','4'] }
+      let(:csv) { "#{header.join(',')}\n#{row1.join(',')}\n"}
+      before(:each) do
+        expect(connection)
+          .to receive(:perform_request_raw)
+          .with('/cons/upload_dataset_map', { api_ver: 2, content_type: "text/csv", accept: "application/json" }, 'PUT',csv)
+          .and_return(response)
+      end
+      let(:response) { Hashie::Mash.new(status: 202,body: "accepted") }
+      it "should convert data into csv and dispatch" do
+        subject.add_data_header(header)
+        subject.add_data_row(row1)
+        expect(subject.save).to be_truthy
+      end
+      context "failure" do
+        let(:response) { Hashie::Mash.new(status: 404,body: "Something bad happened") }
+        it "should return false if save fails" do
+          subject.add_data_header(header)
+          subject.add_data_row(row1)
+          expect(subject.save).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "delete" do
+    context "validations" do
+      it "should complaing if map_id is not provided" do
+        subject.map_id = nil
+        expect(subject.delete).to be false
+        expect(subject.errors.full_messages).to eq(["map_id is missing"])
+      end
+    end
+    context "service" do
+      let(:map_id) { 1 }
+      let(:delete_payload){ {map_id: map_id} }
+      before :each do
+        expect(connection)
+          .to receive(:perform_request_raw)
+          .with('/cons/delete_dataset_map', {api_ver: 2}, 'POST',delete_payload.to_json)
+          .and_return(response)
+      end
+      context "failure" do
+        let(:response) { Hashie::Mash.new(status: 404,body: "Something bad happened") }
+        it "should return false if delete fails" do
+          subject.map_id = map_id
+          expect(subject.delete).to be_falsey
+          expect(subject.errors.full_messages).to eq(["web_service Something bad happened"])
+        end
+      end
+      context "success" do
+        let(:response) { Hashie::Mash.new(status: 200,body: "") }
+        it "should return true" do
+          subject.map_id = map_id
+          expect(subject.delete).to be_truthy
+          expect(subject.errors.full_messages).to eq([])
+        end
+      end
+    end
+  end
+
+  describe "get_dataset_maps" do
+    let(:connection) { BlueStateDigital::Connection.new({}) }
+    let(:dataset_map1) do
+      {
+          map_id:1,
+          type:"state"
+      }
+    end
+    let(:dataset_map2) do
+      {
+          map_id:2,
+          type:"downballot"
+      }
+    end
+    let(:response) do
+      {
+        data:[
+          dataset_map1,
+          dataset_map2
+        ]
+      }.to_json
+    end
+    before :each do
+      expect(connection)
+        .to receive(:perform_request)
+        .with('/cons/list_dataset_maps', {api_ver: 2}, 'GET')
+        .and_return(response)
+    end
+    it "should fetch datasets" do
+      dataset_maps = connection.dataset_maps.get_dataset_maps
+      expect(dataset_maps.length).to eq(2)
+      expect(dataset_maps[0].to_json).to eq(dataset_map1.to_json)
+      expect(dataset_maps[1].to_json).to eq(dataset_map2.to_json)
+    end
+    context "failure" do
+      let(:response) { "Something bad happened" }
+      it "should raise exception if fetch fails" do
+        expect { connection.dataset_maps.get_dataset_maps }.to raise_error(BlueStateDigital::CollectionResource::FetchFailureException)
+      end
+    end
+  end
+end

data/spec/blue_state_digital/dataset_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe BlueStateDigital::Dataset do
+
+  let(:connection) { double }
+  let(:slug) { "my_dataset" }
+  let(:map_type) { "state" }
+  let(:dataset_attributes) do
+    {
+      "dataset_id"  =>  42,
+      "slug"        =>  slug,
+      "rows"        =>  100,
+      "map_type"    =>  map_type
+    }
+  end
+
+  subject { BlueStateDigital::Dataset.new(dataset_attributes.merge({connection: connection}))}
+
+  describe "new" do
+    it "should accept dataset params" do
+      dataset = BlueStateDigital::Dataset.new(dataset_attributes)
+      dataset_attributes.each do |k,v|
+        expect(dataset.send(k)).to eq(v)
+      end
+    end
+  end
+
+  describe "save" do
+    context "validations" do
+      it "should error if required params are not provided" do
+        [:slug,:map_type].each do |field|
+          val = subject.send(field)
+          subject.send("#{field}=",nil)
+          expect(subject).not_to be_valid
+          expect(subject.errors.full_messages).to eq(["#{field} can't be blank"])
+          subject.send("#{field}=",val)
+        end
+      end
+
+      it "should not error if there is no data" do
+        expect(subject.data).to be_blank
+        expect(subject).to be_valid
+      end
+
+      it "should error if there is data but no data header" do
+        subject.add_data_row([1])
+        expect(subject).not_to be_valid
+        expect(subject.errors.full_messages).to eq(["data_header is missing"])
+      end
+    end
+
+    context "csv upload" do
+      let(:header) { ['a','b','c','d'] }
+      let(:row1) { ['1','2','3','4'] }
+      let(:csv) { "#{header.join(',')}\n#{row1.join(',')}\n"}
+      let(:response) { Hashie::Mash.new(status: 202, body: "accepted") }
+
+      before(:each) do
+        expect(connection)
+          .to receive(:perform_request_raw)
+          .with('/cons/upload_dataset', { api_ver: 2, slug: slug,map_type: map_type, content_type: "text/csv", accept: "application/json" }, 'PUT',csv)
+          .and_return(response)
+      end
+
+
+      it "should convert data into csv and dispatch" do
+        subject.add_data_header(header)
+        subject.add_data_row(row1)
+        expect(subject.save).to be_truthy
+      end
+
+      context "failure" do
+        let(:response) { Hashie::Mash.new(status: 404,body: "Something bad happened") }
+
+        it "should return false if save fails" do
+          subject.add_data_header(header)
+          subject.add_data_row(row1)
+          expect(subject.save).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "delete" do
+    context "validations" do
+      it "should complaing if map_id is not provided" do
+        subject.dataset_id = nil
+        expect(subject.delete).to be false
+        expect(subject.errors.full_messages).to eq(["dataset_id is missing"])
+      end
+    end
+
+    context "service" do
+      let(:dataset_id) { 1 }
+      let(:delete_payload){ {dataset_id: dataset_id} }
+
+      before :each do
+        expect(connection)
+          .to receive(:perform_request_raw)
+          .with('/cons/delete_dataset', {api_ver: 2}, 'POST',delete_payload.to_json)
+          .and_return(response)
+      end
+
+      context "failure" do
+        let(:response) { Hashie::Mash.new(status: 404,body: "Something bad happened") }
+
+        it "should return false if delete fails" do
+          subject.dataset_id = dataset_id
+          expect(subject.delete).to be_falsey
+          expect(subject.errors.full_messages).to eq(["web_service Something bad happened"])
+        end
+      end
+
+      context "success" do
+        let(:response) { Hashie::Mash.new(status: 200,body: "") }
+
+        it "should return true" do
+          subject.dataset_id = dataset_id
+          expect(subject.delete).to be_truthy
+          expect(subject.errors.full_messages).to eq([])
+        end
+      end
+    end
+  end
+
+  describe "get_datasets" do
+    let(:connection) { BlueStateDigital::Connection.new({}) }
+    let(:dataset1) do
+      {
+          dataset_id:42,
+          map_type:"state",
+          slug:"my_dataset",
+          rows:100,
+      }
+    end
+
+    let(:dataset2) do
+      {
+          dataset_id:43,
+          map_type:"downballot",
+          slug:"downballot_dataset",
+          rows:50,
+      }
+    end
+
+    let(:response) do
+      {
+        data:[
+          dataset1,
+          dataset2
+        ]
+      }.to_json
+    end
+
+    before :each do
+      expect(connection)
+        .to receive(:perform_request)
+        .with('/cons/list_datasets', { api_ver: 2 }, 'GET')
+        .and_return(response)
+    end
+
+    it "should fetch datasets" do
+      datasets = connection.datasets.get_datasets
+      expect(datasets.length).to eq(2)
+      expect(datasets[0].to_json).to eq(dataset1.to_json)
+      expect(datasets[1].to_json).to eq(dataset2.to_json)
+    end
+
+    context "failure" do
+      let(:response) { "Something bad happened" }
+
+      it "should raise exception if fetch fails" do
+        expect { connection.datasets.get_datasets }.to raise_error(BlueStateDigital::CollectionResource::FetchFailureException)
+      end
+    end
+  end
+end

data/spec/blue_state_digital/email_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe BlueStateDigital::Email do
+    describe :to_hash do
+      it "should return a hash of all fields" do
+        attr_hash = {email: '123432', email_type: 'personal', is_primary: '1', is_subscribed: '0'}
+        phone = BlueStateDigital::Email.new attr_hash
+        expect(phone.to_hash).to eq(attr_hash)
+      end
+      it "should include nil fields" do
+        expected_hash = {email: nil, email_type: nil, is_primary: nil, is_subscribed: nil}
+        phone = BlueStateDigital::Email.new {}
+        expect(phone.to_hash).to eq(expected_hash)
+      end
+    end
+end