blue_state_digital 0.6.0

data/spec/blue_state_digital/constituent_group_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe BlueStateDigital::ConstituentGroup do
+  before(:each) do
+    @empty_response = <<-xml_string
+    <?xml version="1.0" encoding="utf-8"?>
+    <api>
+    </api>
+    xml_string
+    @empty_response.strip!
+
+    @multiple_cons_groups = <<-xml_string
+<?xml version="1.0" encoding="utf-8"?>
+<api>
+<cons_group id='12' modified_dt="1171861200">
+    <name>First Quarter Donors</name>
+    <slug>q1donors</slug>
+    <description>People who donated in Q1 2007</description>
+    <is_banned>0</is_banned>
+    <create_dt>1168146000</create_dt>
+    <group_type>manual</group_type>
+    <members>162</members>
+    <unique_emails>164</unique_emails>
+    <unique_emails_subscribed>109</unique_emails_subscribed>
+    <count_dt>1213861583</count_dt>
+</cons_group>
+<cons_group id='13' modified_dt="1171861200">
+    <name>Second Quarter Donors</name>
+    <slug>q2donors</slug>
+    <description>People who donated in Q1 2007</description>
+    <is_banned>0</is_banned>
+    <create_dt>1168146000</create_dt>
+    <group_type>manual</group_type>
+    <members>162</members>
+    <unique_emails>164</unique_emails>
+    <unique_emails_subscribed>109</unique_emails_subscribed>
+    <count_dt>1213861583</count_dt>
+</cons_group>
+</api>
+xml_string
+
+    @single_cons_groups = <<-xml_string
+<?xml version="1.0" encoding="utf-8"?>
+<api>
+<cons_group id='13' modified_dt="1171861200">
+    <name>First Quarter Donors</name>
+    <slug>q1donors</slug>
+    <description>People who donated in Q1 2007</description>
+    <is_banned>0</is_banned>
+    <create_dt>1168146000</create_dt>
+    <group_type>manual</group_type>
+    <members>162</members>
+    <unique_emails>164</unique_emails>
+    <unique_emails_subscribed>109</unique_emails_subscribed>
+    <count_dt>1213861583</count_dt>
+</cons_group>
+</api>
+xml_string
+
+  end
+
+  let(:connection) { BlueStateDigital::Connection.new({}) }
+
+  describe ".list_constituent_groups" do
+    it "should return a list of groups" do
+      expect(connection).to receive(:perform_request).with('/cons_group/list_constituent_groups', {}, "GET").and_return(@multiple_cons_groups)
+      groups = connection.constituent_groups.list_constituent_groups
+      expect(groups).to be_a(Array)
+      expect(groups.length).to eq(2)
+    end
+  end
+
+  describe ".find_by_id" do
+    it "should do a list comprehension to find a group in the list by id" do
+      expect(connection).to receive(:perform_request).with('/cons_group/get_constituent_group', {cons_group_id: 13}, "GET").and_return(@single_cons_groups)
+      group = connection.constituent_groups.find_by_id(13)
+      expect(group).to be_a(BlueStateDigital::ConstituentGroup)
+      expect(group.id).to eq('13')
+    end
+
+    it "should handle an empty result" do
+      expect(connection).to receive(:perform_request).with('/cons_group/get_constituent_group', {cons_group_id: 13}, "GET").and_return(@empty_response)
+      group = connection.constituent_groups.find_by_id(13)
+      expect(group).to be_nil
+    end
+  end
+
+  describe ".delete_constituent_groups" do
+    it "should handle an array of integers" do
+      expect(connection).to receive(:perform_request).with('/cons_group/delete_constituent_groups', {:cons_group_ids=>"2,3"}, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(true)
+      connection.constituent_groups.delete_constituent_groups([2,3])
+    end
+
+    it "should handle a single integer" do
+      expect(connection).to receive(:perform_request).with('/cons_group/delete_constituent_groups', {:cons_group_ids=>"2"}, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(true)
+
+      connection.constituent_groups.delete_constituent_groups(2)
+    end
+  end
+
+  describe ".find_or_create" do
+    before(:all) do
+      @timestamp = Time.now.to_i
+
+      @new_group_xml = <<-xml_string
+<?xml version="1.0" encoding="utf-8"?>
+<api>
+<cons_group>
+<name>Environment</name>
+<slug>environment</slug>
+<description>Environment Group</description>
+<group_type>manual</group_type>
+<create_dt>#{@timestamp}</create_dt>
+</cons_group>
+</api>
+xml_string
+      @new_group_xml.gsub!(/\n/, "")
+
+      @exists_response = <<-xml_string
+<?xml version="1.0" encoding="utf-8"?>
+<api>
+<cons_group id='12'>
+</cons_group>
+</api>
+xml_string
+      @exists_response.strip!
+    end
+
+    it "should create a new group" do
+      attrs = { name: "Environment", slug: "environment", description: "Environment Group", group_type: "manual", create_dt: @timestamp }
+
+
+      expect(connection).to receive(:perform_request).with('/cons_group/get_constituent_group_by_slug', {slug:attrs[:slug]}, "GET") { @empty_response }
+      expect(connection).to receive(:perform_request).with('/cons_group/add_constituent_groups', {}, "POST", @new_group_xml) { @exists_response }
+
+      cons_group = connection.constituent_groups.find_or_create(attrs)
+      expect(cons_group.id).to eq('12')
+    end
+
+
+    it "should not create group if it already exists" do
+      attrs = { name: "Environment", slug: "environment", description: "Environment Group", group_type: "manual", create_dt: @timestamp }
+
+      expect(connection).to receive(:perform_request).with('/cons_group/get_constituent_group_by_slug', {slug:attrs[:slug]}, "GET") { @exists_response }
+      expect(connection).not_to receive(:perform_request).with('/cons_group/add_constituent_groups', {}, "POST", @new_group_xml)
+
+      cons_group = connection.constituent_groups.find_or_create(attrs)
+      expect(cons_group.id).to eq('12')
+    end
+  end
+
+  describe ".from_response" do
+    describe "a single group" do
+      before(:each) do
+        @response = <<-xml_string
+    <?xml version="1.0" encoding="utf-8"?>
+    <api>
+    <cons_group id='12' modified_dt="1171861200">
+        <name>First Quarter Donors</name>
+        <slug>q1donors</slug>
+        <description>People who donated in Q1 2007</description>
+        <is_banned>0</is_banned>
+        <create_dt>1168146000</create_dt>
+        <group_type>manual</group_type>
+        <members>162</members>
+        <unique_emails>164</unique_emails>
+        <unique_emails_subscribed>109</unique_emails_subscribed>
+        <count_dt>1213861583</count_dt>
+    </cons_group>
+    </api>
+    xml_string
+      end
+
+      it "should create a group from an xml string" do
+        response = connection.constituent_groups.send(:from_response, @response)
+        expect(response.id).to eq("12")
+        expect(response.slug).to eq('q1donors')
+      end
+    end
+
+    describe "multiple groups" do
+      it "should create an array of groups from an xml string" do
+        response = connection.constituent_groups.send(:from_response, @multiple_cons_groups)
+        expect(response).to be_a(Array)
+        first = response.first
+        expect(first.id).to eq("12")
+        expect(first.slug).to eq('q1donors')
+      end
+    end
+  end
+
+  [[:add, 'add_cons_ids_to_group'], [:remove, 'remove_cons_ids_from_group']].each do |(operation, method)|
+    # operation, method = method_under_test.key, method_under_test.value
+
+    it "should #{operation} constituent ids to group" do
+      cons_group_id = "12"
+      cons_ids = ["1", "2"]
+      post_params = { cons_group_id: cons_group_id, cons_ids: "1,2" }
+
+      expect(connection).to receive(:perform_request).with("/cons_group/#{method}", post_params, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(true)
+
+      connection.constituent_groups.send(method.to_sym, cons_group_id, cons_ids)
+    end
+
+    it "should batch on #{operation} constituent ids to group" do
+      stub_const('BlueStateDigital::ConstituentGroups::CONSTITUENTS_BATCH_SIZE', 2)
+
+      cons_group_id = "12"
+      cons_ids = ["1", "2", "3", "4"]
+
+      expect(connection).to receive(:perform_request).with("/cons_group/#{method}", { cons_group_id: cons_group_id, cons_ids: "1,2" }, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with("/cons_group/#{method}", { cons_group_id: cons_group_id, cons_ids: "3,4" }, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").twice.and_return(true)
+
+      connection.constituent_groups.send(method.to_sym, cons_group_id, cons_ids)
+    end
+
+    it "should not wait for the result if told not to" do
+      cons_group_id = "12"
+      cons_ids = ["1", "2"]
+      post_params = { cons_group_id: cons_group_id, cons_ids: "1,2" }
+
+      expect(connection).to receive(:perform_request).with("/cons_group/#{method}", post_params, "POST").and_return("deferred_id")
+      expect(connection).not_to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET")
+
+      connection.constituent_groups.send(method.to_sym, cons_group_id, cons_ids,  {wait_for_result: false})
+    end
+
+    it "should #{operation} a single constituent id to a group" do
+      cons_group_id = "12"
+      cons_ids = ["1"]
+      post_params = { cons_group_id: cons_group_id, cons_ids: "1" }
+
+      expect(connection).to receive(:perform_request).with("/cons_group/#{method}", post_params, "POST").and_return("deferred_id")
+      expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(true)
+
+      connection.constituent_groups.send(method.to_sym, cons_group_id, cons_ids)
+    end
+  end
+
+
+  it "should rename the constituent group" do
+    expect(connection).to receive(:perform_request).with('/cons_group/rename_group', {cons_group_id: "1", new_name: "foo"}, "POST").and_return("")
+    connection.constituent_groups.rename_group("1", "foo")
+  end
+
+  it "should allow replace_constituent_group!" do
+    old_cons_group_id = 15
+    new_cons_group_id = 1
+    attrs = { name: "Environment", slug: "environment", description: "Environment Group", group_type: "manual", create_dt: @timestamp }
+    new_group = double
+    allow(new_group).to receive(:id).and_return(new_cons_group_id)
+
+    old_group = double
+    allow(old_group).to receive(:id).and_return(old_cons_group_id)
+
+
+    expect(connection.constituent_groups).to receive(:get_constituent_group).with(old_cons_group_id).and_return( old_group )
+    expect(connection.constituent_groups).to receive(:find_or_create).with(attrs).and_return( new_group )
+    expect(connection.constituent_groups).to receive(:get_cons_ids_for_group).with(old_cons_group_id).and_return( [1, 2, 3] )
+    expect(connection.constituent_groups).to receive(:add_cons_ids_to_group).with(new_cons_group_id, [1, 2, 3] )
+    expect(connection.constituent_groups).to receive(:delete_constituent_groups).with( old_cons_group_id )
+
+    expect(connection.constituent_groups.replace_constituent_group!(old_cons_group_id, attrs)).to eq(new_group)
+  end
+end

data/spec/blue_state_digital/constituent_spec.rb

@@ -0,0 +1,422 @@
+require 'spec_helper'
+
+describe BlueStateDigital::Constituent do
+  describe ".to_xml" do
+    before(:each) do
+      @cons = BlueStateDigital::Constituent.new({})
+    end
+
+    context "with addresses" do
+      let(:expected_result) do
+        <<-xml_string.split("\n").map(&:strip).join
+          <?xml version="1.0" encoding="utf-8"?>
+          <api>
+            <cons>
+              <cons_addr>
+                <addr1>one</addr1>
+              </cons_addr>
+            </cons>
+          </api>
+        xml_string
+      end
+      it "should allow constituent addresses entries as hashes" do 
+        constituent = BlueStateDigital::Constituent.new addresses: [{addr1: 'one'}] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+      it "should allow constituent addresses entries as BlueStateDigital::Addresses" do 
+        constituent = BlueStateDigital::Constituent.new addresses: [BlueStateDigital::Address.new(addr1: 'one')] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+
+    end
+
+    context "with emails" do
+      let(:expected_result) do
+        <<-xml_string.split("\n").map(&:strip).join
+          <?xml version="1.0" encoding="utf-8"?>
+          <api>
+            <cons>
+              <cons_email>
+                <email>one@two.com</email>
+              </cons_email>
+            </cons>
+          </api>
+        xml_string
+      end
+      it "should allow constituent addresses entries as hashes" do 
+        constituent = BlueStateDigital::Constituent.new emails: [{email: 'one@two.com'}] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+      it "should allow constituent addresses entries as BlueStateDigital::Addresses" do 
+        constituent = BlueStateDigital::Constituent.new emails: [BlueStateDigital::Email.new(email: 'one@two.com')] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+
+    end
+
+    context "with phone numbers" do
+      let(:expected_result) do
+        <<-xml_string.split("\n").map(&:strip).join
+          <?xml version="1.0" encoding="utf-8"?>
+          <api>
+            <cons>
+              <cons_phone>
+                <phone>123321123</phone>
+              </cons_phone>
+            </cons>
+          </api>
+        xml_string
+      end
+      it "should allow constituent addresses entries as hashes" do 
+        constituent = BlueStateDigital::Constituent.new phones: [{phone: '123321123'}] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+      it "should allow constituent addresses entries as BlueStateDigital::Addresses" do 
+        constituent = BlueStateDigital::Constituent.new phones: [BlueStateDigital::Phone.new(phone: '123321123')] 
+        expect(constituent.to_xml).to eq(expected_result)
+      end
+
+    end
+
+    [:firstname,:lastname,:is_banned,:create_dt,:birth_dt,:gender].each do |param|
+      describe "with #{param}" do
+        let (:expected_result) do
+          <<-xml_string.split("\n").map(&:strip).join
+            <?xml version="1.0" encoding="utf-8"?>
+            <api>
+              <cons>
+                <#{param.to_s}>#{param.to_s}_value</#{param.to_s}>
+              </cons>
+            </api>
+          xml_string
+        end
+        it "should be present as #{param.to_s} tag in cons tag" do
+          constituent = BlueStateDigital::Constituent.new 
+          eval("constituent.#{param.to_s}='#{param.to_s}_value'")
+          expect(constituent.to_xml).to eq(expected_result)
+        end 
+
+      end
+    end
+  end
+
+  let(:connection) { BlueStateDigital::Connection.new({}) }
+
+  describe "Get Constituents" do
+    before(:each) do
+      @single_constituent = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <middlename>Reginald</middlename>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+          <suffix>III</suffix>
+          <prefix>Mr</prefix>
+          <gender>M</gender>
+      </cons>
+      </api>
+      xml_string
+
+      @constituent_with_group = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+
+          <cons_group id="41" modified_dt="1163196031" />
+      </cons>
+      </api>
+      xml_string
+
+      @constituent_with_addr = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+          <cons_addr id="43" modified_dt="1355800948">
+            <addr1>yyy2</addr1>
+            <addr2>yyy3</addr2>
+            <city>here</city>
+            <state_cd>2323</state_cd>
+            <zip>00323</zip>
+            <country></country>
+            <latitude>0.000000</latitude>
+            <longitude>0.000000</longitude>
+            <is_primary>0</is_primary>
+            <cons_addr_type_id>0</cons_addr_type_id>
+          </cons_addr>
+          <cons_addr id="42" modified_dt="1355800946">
+            <addr1>xxx1</addr1>
+            <addr2>xxx2</addr2>
+            <city>Helsinki</city>
+            <state_cd></state_cd>
+            <zip>12345</zip>
+            <country>AM</country>
+            <latitude>42.810059</latitude>
+            <longitude>-73.951050</longitude>
+            <is_primary>1</is_primary>
+            <cons_addr_type_id>0</cons_addr_type_id>
+          </cons_addr>
+      </cons>
+      </api>
+      xml_string
+
+      @constituent_with_emails = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+
+          <cons_email id="35" modified_dt="1355796381">
+            <email>gil+punky1@thoughtworks.com</email>
+            <email_type>personal</email_type>
+            <is_subscribed>1</is_subscribed>
+            <is_primary>1</is_primary>
+          </cons_email>
+          <cons_email id="36" modified_dt="1355796381">
+            <email>fred@thoughtworks.com</email>
+            <email_type>internal</email_type>
+            <is_subscribed>0</is_subscribed>
+            <is_primary>0</is_primary>
+          </cons_email>
+      </cons>
+      </api>
+      xml_string
+
+      @constituent_with_groups = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+
+          <cons_group id="17"  modified_dt="1168146011"/>
+          <cons_group id="41" modified_dt="1163196031" />
+      </cons>
+      </api>
+      xml_string
+
+      @multiple_constituents = <<-xml_string
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+      <cons id="4382" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Bob</firstname>
+          <middlename>Reginald</middlename>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+          <suffix>III</suffix>
+          <prefix>Mr</prefix>
+          <gender>M</gender>
+      </cons>
+
+      <cons id="4381" modified_dt="1171861200">
+          <guid>ygdFPkyEdomzBhWEFZGREys</guid>
+          <firstname>Susan</firstname>
+          <middlename>Reginald</middlename>
+          <lastname>Smith</lastname>
+          <has_account>1</has_account>
+          <is_banned>0</is_banned>
+          <create_dt>1168146000</create_dt>
+          <suffix></suffix>
+          <prefix>Mrs</prefix>
+          <gender>F</gender>
+      </cons>
+      </api>
+      xml_string
+    end
+
+    describe ".get_constituents_by_email" do
+      it "should make a filtered constituents query" do
+        expect(connection).to receive(:perform_request).with('/cons/get_constituents', {:filter=>"email=george@washington.com", :bundles => 'cons_group'}, "GET").and_return("deferred_id")
+        expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(@single_constituent)
+        response = connection.constituents.get_constituents_by_email("george@washington.com").first
+        expect(response.id).to eq("4382")
+        expect(response.firstname).to eq('Bob')
+      end
+
+      it "should return constituents' details based on bundles" do
+        bundles = 'cons_addr'
+        expect(connection).to receive(:perform_request).with('/cons/get_constituents', {:filter=>"email=george@washington.com", :bundles => bundles}, "GET").and_return("deferred_id")
+        expect(connection).to receive(:perform_request).with('/get_deferred_results', {deferred_id: "deferred_id"}, "GET").and_return(@constituent_with_addr)
+        response = connection.constituents.get_constituents_by_email("george@washington.com", ['cons_addr']).first
+        response.addresses[0].addr1 == "aaa1"
+        response.addresses[0].addr2 == "aaa2"
+      end
+    end
+
+    describe ".get_constituents_by_id" do
+      it "should return a constituent" do
+        expect(connection).to receive(:perform_request).with('/cons/get_constituents_by_id', {:cons_ids=>"23", :bundles => 'cons_group'}, "GET").and_return(@single_constituent)
+        response = connection.constituents.get_constituents_by_id("23").first
+        expect(response.id).to eq("4382")
+        expect(response.firstname).to eq('Bob')
+      end
+    end
+
+    describe ".from_response" do
+      it "should set connection in generated constituents" do
+        response = connection.constituents.send(:from_response, @single_constituent)
+        expect(response).to be_a(Array)
+        expect(response.size).to eq(1)
+        expect(response.first.connection).to eq(connection)
+      end
+
+      it "should create an array of constituents from a response that contains multiple constituents" do
+        response = connection.constituents.send(:from_response, @multiple_constituents)
+        expect(response).to be_a(Array)
+        first = response.first
+        expect(first.id).to eq("4382")
+        expect(first.firstname).to eq('Bob')
+      end
+
+      it "should create an array of single constituent when only one is supplied" do
+        response = connection.constituents.send(:from_response, @single_constituent)
+        expect(response).to be_a(Array)
+        expect(response.size).to eq(1)
+        expect(response.first.id).to eq("4382")
+        expect(response.first.firstname).to eq('Bob')
+        expect(response.first.gender).to eq('M')
+      end
+
+      it "should handle constituent group membership" do
+        response = connection.constituents.send(:from_response, @constituent_with_groups).first
+        expect(response.id).to eq('4382')
+        expect(response.group_ids).to eq(["17", "41"])
+      end
+
+      it "should handle single constituent group membership" do
+        response = connection.constituents.send(:from_response, @constituent_with_group).first
+        expect(response.id).to eq('4382')
+        expect(response.group_ids).to eq(["41"])
+      end
+
+      it "Should handle constituent addresses" do
+        response = connection.constituents.send(:from_response, @constituent_with_addr).first
+        expect(response.addresses.size).to eq(2)
+        expect(response.addresses[0]).to be_a BlueStateDigital::Address
+        expect(response.addresses[0].addr1).to eq("yyy2")
+        expect(response.addresses[0].addr2).to eq("yyy3")
+
+        expect(response.addresses[1]).to be_a BlueStateDigital::Address
+        expect(response.addresses[1].addr1).to eq("xxx1")
+        expect(response.addresses[1].addr2).to eq("xxx2")
+      end
+
+      it "Should handle constituent email addresses" do
+        response = connection.constituents.send(:from_response, @constituent_with_emails).first
+        expect(response.emails.size).to eq(2)
+        expect(response.emails[0]).to be_a BlueStateDigital::Email
+        expect(response.emails[0].email).to eq("gil+punky1@thoughtworks.com")
+        expect(response.emails[0].email_type).to eq("personal")
+        expect(response.emails[0].is_subscribed).to eq("1")
+        expect(response.emails[0].is_primary).to eq("1")
+
+        expect(response.emails[1]).to be_a BlueStateDigital::Email
+        expect(response.emails[1].email).to eq("fred@thoughtworks.com")
+        expect(response.emails[1].email_type).to eq("internal")
+        expect(response.emails[1].is_subscribed).to eq("0")
+        expect(response.emails[1].is_primary).to eq("0")
+      end
+
+    end
+  end
+
+  describe "delete_constituents_by_id" do
+    it "should handle an array of integers" do
+      expect(connection).to receive(:perform_request).with('/cons/delete_constituents_by_id', {:cons_ids=>"2,3"}, "POST")
+      connection.constituents.delete_constituents_by_id([2,3])
+    end
+
+    it "should handle a single integer" do
+      expect(connection).to receive(:perform_request).with('/cons/delete_constituents_by_id', {:cons_ids=>"2"}, "POST")
+      connection.constituents.delete_constituents_by_id(2)
+    end
+  end
+  it "should set constituent data" do
+    timestamp = Time.now.to_i
+
+    data = {
+      id: 'id',
+      firstname: 'First',
+      lastname: 'Last',
+      is_banned: 0,
+      create_dt: timestamp,
+      emails: [{ email: "email@email.com", email_type: "work", is_subscribed: 1, is_primary: 1 }],
+      groups: [3, 5],
+      connection: connection
+    }
+
+    input = %q{<?xml version="1.0" encoding="utf-8"?>}
+    input << "<api>"
+    input << "<cons id=\"id\">"
+    input << "<firstname>First</firstname>"
+    input << "<lastname>Last</lastname>"
+    input << "<is_banned>0</is_banned>"
+    input << "<create_dt>#{timestamp}</create_dt>"
+    input << "<cons_email>"
+    input << "<email>email@email.com</email>"
+    input << "<email_type>work</email_type>"
+    input << "<is_subscribed>1</is_subscribed>"
+    input << "<is_primary>1</is_primary>"
+    input << "</cons_email>"
+    input << "<cons_group id=\"3\"/>"
+    input << "<cons_group id=\"5\"/>"
+    input << "</cons>"
+    input << "</api>"
+
+    output = %q{<?xml version="1.0" encoding="utf-8"?>}
+    output << "<api>"
+    output << "<cons is_new='1' id='329'>"
+    output << "</cons>"
+    output << "</api>"
+
+    expect(connection).to receive(:perform_request).with('/cons/set_constituent_data', {}, "POST", input) { output }
+
+    cons_data = BlueStateDigital::Constituent.new(data)
+    cons_data.save
+    expect(cons_data.id).to eq('329')
+    expect(cons_data.is_new).to eq('1')
+    expect(cons_data.is_new?).to be_truthy
+  end
+
+  describe "#to_xml" do
+    it "should convert a constituent hash to xml" do
+      cons = BlueStateDigital::Constituent.new ({
+          firstname: 'George',
+          lastname: 'Washington',
+          create_dt: Time.now.to_i,
+          emails: [{ email: 'george@washington.com', is_subscribed: 1}],
+          addresses: [{ country: 'US', zip: '20001', is_primary: 1}],
+          phones: [{phone: '123456789', phone_type: 'unknown'}]
+      })
+      expect(cons.to_xml).not_to be_nil
+    end
+  end
+end