blue_state_digital 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4e8917551b5e90a45a3c448cf6f58804e9175bb3
-  data.tar.gz: b22e282e7cd262c56f50f51fe21cf64dd25cc51e
+SHA256:
+  metadata.gz: 4c617aba30c10bd08e560236ecebebdaf6a6698a9e55fbb5c17beb2284aedd5e
+  data.tar.gz: d1529a6282f4c39dabd7177999409f58a741573d400c2d3a4c4bc285c8b89630
 SHA512:
-  metadata.gz: ae5ab46979afce07ca7d8af7b8ce5d28e99765c403055f901502948deb9109ac9dbb2a2f4c68e6e38c4e3fcd6f7c8905f49d14ecac4d29f4e5eb308e7bf93edb
-  data.tar.gz: 8667e65c8301f175e99ecf8ec7152849c8bb612e1c9ccd26773665b015bc7834e8cea566849b75dad4aa1c1d19d330dee761334d671bdc53c1cef93a63de2db3
+  metadata.gz: f7f79e29f4c914a2e3fcccb809b866eae767ea97552131d739bcdb7f6981b88f9520574047165c3abcedad8d21ef0115609c2d3d74de88bc4519b28a790cc0ba
+  data.tar.gz: 11483f192126b7ea23da98263cb4ef074bde678dd43b8fc8bc05dfe5fbdd887a6feb850c6beed20ea5db72ad3a7f77a4f831ccfe35f8e5315236e2791d0e60c0

data/.ruby-version

@@ -1 +1 @@
-ruby-2.2.3
+2.5.1

data/.travis.yml

@@ -1,3 +1,3 @@
 language: ruby
 rvm:
-  - "2.2.3"
+  - "2.3.4"

data/README.md

@@ -11,25 +11,38 @@ gem blue_state_digital
 Configuration:
 
 ```ruby
-connection = BlueStateDigital::Connection.new(host:'foo.com' api_id: 'bar', api_secret: 'magic_secret')
+connection = BlueStateDigital::Connection.new(host:'foo.com', api_id: 'bar', api_secret: 'magic_secret')
 cons = BlueStateDigital::Constituent.new({firstname: 'George', lastname: 'Washington', emails: [{ email: 'george@washington.com'}]}.merge({connection: connection}))
 cons.save
-cons.Id # created constituent ID
+cons.id # created constituent ID
 ```
 
 Use the event machine adapter:
 
 ```ruby
-connection = BlueStateDigital::Connection.new(host:'foo.com' api_id: 'bar', api_secret: 'magic_secret', adapter: :em_synchrony)
+connection = BlueStateDigital::Connection.new(host:'foo.com', api_id: 'bar', api_secret: 'magic_secret', adapter: :em_synchrony)
 ```
 
 ### Unsubscribes
 
 ```ruby
-connection = BlueStateDigital::Connection.new(host:'foo.com' api_id: 'bar', api_secret: 'magic_secret')
+connection = BlueStateDigital::Connection.new(host:'foo.com', api_id: 'bar', api_secret: 'magic_secret')
 unsub = BlueStateDigital::EmailUnsubscribe.new({email: 'george@washington.com', reason: 'tea in the harbor'}.merge({connection: connection}))
 unsub.unsubscribe! # raises on error, returns true on success.
+```
+
+### Signup Forms
 
+```ruby
+connection = BlueStateDigital::Connection.new(host:'foo.com', api_id: 'bar', api_secret: 'magic_secret')
+signup_form = BlueStateDigital::SignupForm.clone(clone_from_id: 3, slug: 'foo', name: 'my new form', public_title: 'Sign Here For Puppies', connection: connection)
+signup_form.set_cons_group(2345)
+fields = signup_form.form_fields  # returns a list of SignupFormField
+
+# The keys of the field_data hash should match the labels of the signup form's fields
+signup_form.process_signup(field_data: {'First Name' => 'George', 'Last Name' => 'Washington', 'Email Address' => 'george@example.com', 'A Custom Field' => 'some custom data'},
+                           email_opt_in: true, source: 'foo', subsource: 'bar')
+```
 
 ### Dataset integration 
 

data/lib/blue_state_digital.rb

@@ -25,8 +25,9 @@ require "blue_state_digital/dataset"
 require "blue_state_digital/dataset_map"
 require "blue_state_digital/error_middleware"
 require "blue_state_digital/email_unsubscribe"
+require "blue_state_digital/signup_form"
 
 
 I18n.enforce_available_locales = false
 
-Faraday::Response.register_middleware :error_middleware  => lambda { BlueStateDigital::ErrorMiddleware }
+Faraday::Response.register_middleware :error_middleware  => lambda { BlueStateDigital::ErrorMiddleware }

data/lib/blue_state_digital/connection.rb

@@ -1,4 +1,6 @@
 module BlueStateDigital
+  class DeferredResultTimeout < StandardError ; end
+
   class Connection
     API_VERSION = 2
     API_BASE = '/page/api'
@@ -6,9 +8,13 @@ module BlueStateDigital
 
     attr_reader :constituents, :constituent_groups, :datasets, :dataset_maps
 
+    attr_accessor :instrumentation
+
     def initialize(params = {})
       @api_id = params[:api_id]
       @api_secret = params[:api_secret]
+      self.instrumentation = params[:instrumentation]
+
       @client = Faraday.new(:url => "https://#{params[:host]}/") do |faraday|
         faraday.request  :url_encoded             # form-encode POST params
         if defined?(Rails) && Rails.env.development?
@@ -26,7 +32,16 @@ module BlueStateDigital
 
     def perform_request_raw(call, params = {}, method = "GET", body = nil)
       path = API_BASE + call
-      if method == "POST" || method == "PUT"
+
+      # instrumentation is a Proc that is called for each request that is performed.
+      if self.instrumentation
+        stats = {}
+        stats[:path] = path
+        stats[:api_id] = @api_id
+        self.instrumentation.call(stats)
+      end
+
+      resp = if method == "POST" || method == "PUT"
         @client.send(method.downcase.to_sym) do |req|
           content_type = params.delete(:content_type) || 'application/x-www-form-urlencoded'
           accept = params.delete(:accept) || 'text/xml'
@@ -39,6 +54,8 @@ module BlueStateDigital
       else
         @client.get(path, extended_params(path, params))
       end
+
+      resp
     end
 
     def perform_graph_request(call, params, method = 'POST')
@@ -106,11 +123,18 @@ module BlueStateDigital
       end
     end
 
-    def wait_for_deferred_result(deferred_id)
+    def wait_for_deferred_result(deferred_id, timeout = 600)
       result = nil
+      time_waiting = 0
       while result.nil? || (result.respond_to?(:length) && result.length == 0)
         result = retrieve_results(deferred_id)
-        sleep(2) if result.nil? || (result.respond_to?(:length) && result.length == 0)
+        if result.nil? || (result.respond_to?(:length) && result.length == 0)
+          time_waiting = time_waiting + 2
+          if time_waiting > timeout
+            raise BlueStateDigital::DeferredResultTimeout.new("exceeded timeout #{timeout} seconds waiting for #{deferred_id}")
+          end
+          sleep(2)
+        end
       end
       result
     end

data/lib/blue_state_digital/constituent.rb

@@ -11,14 +11,14 @@ module BlueStateDigital
     end
 
     def save
-      xml = connection.perform_request '/cons/set_constituent_data', {}, "POST", self.to_xml
+      xml = connection.wait_for_deferred_result(  connection.perform_request '/cons/upsert_constituent_data', {}, "POST", self.to_xml )
       doc = Nokogiri::XML(xml)
-      record =  doc.xpath('//cons').first
+      record = doc.xpath('//cons').first
       if record
         self.id = record[:id]
         self.is_new = record[:is_new]
       else
-        raise "Set constituent data failed with message: #{xml}"
+        raise "upsert_constituent_data failed with message: #{xml}"
       end
       self
     end
@@ -96,17 +96,19 @@ module BlueStateDigital
 
   class Constituents < CollectionResource
     def get_constituents_by_email email, bundles= [ 'cons_group' ]
-      get_constituents "email=#{email}", bundles
+      result = connection.perform_request('/cons/get_constituents_by_email', filter_parameters({emails: email, :bundles=> bundles.join(',')}), "GET")
+
+      from_response(result)
     end
 
     def get_constituents_by_id(cons_ids, bundles = ['cons_group'])
       cons_ids_concat = cons_ids.is_a?(Array) ? cons_ids.join(',') : cons_ids.to_s
 
-      from_response(connection.perform_request('/cons/get_constituents_by_id', {:cons_ids => cons_ids_concat, :bundles=> bundles.join(',')}, "GET"))
+      from_response(connection.perform_request('/cons/get_constituents_by_id', filter_parameters({:cons_ids => cons_ids_concat, :bundles=> bundles.join(',')}), "GET"))
     end
 
     def get_constituents(filter, bundles = [ 'cons_group' ])
-      result = connection.wait_for_deferred_result( connection.perform_request('/cons/get_constituents', {:filter => filter, :bundles=> bundles.join(',')}, "GET") )
+      result = connection.wait_for_deferred_result( connection.perform_request('/cons/get_constituents', filter_parameters({:filter => filter, :bundles=> bundles.join(',')}), "GET") )
 
       from_response(result)
     end
@@ -174,5 +176,13 @@ module BlueStateDigital
 
       cons
     end
+
+    private
+
+    def filter_parameters(params) 
+      params.delete_if do |key, value|
+        value.blank?
+      end
+    end
   end
 end

data/lib/blue_state_digital/error_middleware.rb

@@ -2,6 +2,7 @@ module BlueStateDigital
   class Unauthorized < ::Faraday::Error::ClientError ; end
   class ResourceDoesNotExist < ::Faraday::Error::ClientError ; end
   class EmailNotFound < ::Faraday::Error::ClientError ; end
+  class XmlErrorResponse < ::Faraday::Error::ClientError ; end
 
   class ErrorMiddleware < ::Faraday::Response::RaiseError
     def on_complete(env)
@@ -11,7 +12,9 @@ module BlueStateDigital
       when 403
         raise BlueStateDigital::Unauthorized, response_values(env).to_s
       when 409
-        if env.body =~ /does not exist/
+        if env.body =~ /<error>/
+          raise BlueStateDigital::XmlErrorResponse, env.body
+        elsif env.body =~ /does not exist/
           raise BlueStateDigital::ResourceDoesNotExist, response_values(env).to_s
         elsif env.body =~ /Email not found/
           raise BlueStateDigital::EmailNotFound, response_values(env).to_s
@@ -26,4 +29,4 @@ module BlueStateDigital
       end
     end
   end
-end
+end

data/lib/blue_state_digital/event.rb

@@ -10,7 +10,8 @@ module BlueStateDigital
       end
     end
 
-    FIELDS = [:event_id_obfuscated, :event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd, :start_date, :end_date]
+    FIELDS = [:event_id_obfuscated, :event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country,
+              :venue_zip, :venue_city, :venue_state_cd, :start_date, :end_date, :local_timezone]
     attr_accessor *FIELDS
 
     def save
@@ -37,7 +38,7 @@ module BlueStateDigital
       end
 
       duration_in_minutes = ((end_date - start_date) / 60).to_i
-      day_attrs = { start_datetime_system: start_date.strftime('%Y-%m-%d %H:%M:%S %z'), duration: duration_in_minutes }
+      day_attrs = { start_datetime_system: start_date.strftime('%Y-%m-%d %H:%M:%S'), duration: duration_in_minutes }
       event_attrs[:days] = [ day_attrs ]
 
       event_attrs.to_json

data/lib/blue_state_digital/signup_form.rb

@@ -0,0 +1,93 @@
+module BlueStateDigital
+  class SignupFormField < ApiDataModel
+    FIELDS = [:id, :format, :label, :description, :is_required, :is_custom_field, :cons_field_id, :create_dt]
+    attr_accessor *FIELDS
+
+    # Takes a <signup_form_field> block already processed by Nokogiri
+    def self.from_xml(xml_record)
+      SignupFormField.new(id: xml_record[:id],
+                          format: xml_record.xpath('format').text,
+                          label: xml_record.xpath('label').text,
+                          description: xml_record.xpath('description').text,
+                          is_required: xml_record.xpath('is_required').text == '1',
+                          is_custom_field: xml_record.xpath('is_custom_field').text == '1',
+                          cons_field_id: xml_record.xpath('cons_field_id').text.to_i,
+                          create_dt: xml_record.xpath('create_dt').text)
+    end
+  end
+
+  class SignupForm < ApiDataModel
+    FIELDS = [:id, :name, :slug, :public_title, :create_dt]
+    attr_accessor *FIELDS
+
+    def self.clone(clone_from_id:, slug:, name:, public_title:, connection:)
+      params = {signup_form_id: clone_from_id, title: public_title, signup_form_name: name, slug: slug}
+      xml_response = connection.perform_request '/signup/clone_form', {}, 'POST', params
+
+      doc = Nokogiri::XML(xml_response)
+      record = doc.xpath('//signup_form').first
+      if record
+        id = record.xpath('id').text.to_i
+        SignupForm.new(id: id, name: name, slug: slug, public_title: public_title, connection: connection)
+      else
+        raise "Cloning signup form failed with message: #{xml_response}"
+      end
+    end
+
+    # field_data is a hash mapping field labels to field values, like {'First Name' => 'Alice'}
+    def process_signup(field_data:, email_opt_in: false, source: nil, subsource: nil)
+      # Construct the XML to send
+      builder = Builder::XmlMarkup.new
+      builder.instruct! :xml, version: '1.0', encoding: 'utf-8'
+      xml_body = builder.api do |api|
+        api.signup_form(id: self.id) do |form|
+          form_fields.each do |field|
+            form.signup_form_field(field_data[field.label], id: field.id)
+          end
+          unless email_opt_in.nil?
+            form.email_opt_in(email_opt_in ? '1' : '0')            
+          end
+          form.source(source) unless source.nil?
+          form.subsource(subsource) unless subsource.nil?
+        end
+      end
+
+      # Post it to the endpoint
+      begin
+        response = connection.perform_request_raw '/signup/process_signup', {}, 'POST', xml_body
+        if response.status >= 200 && response.status < 300
+          return true
+        else
+          raise "process signup failed with message: #{response.body}"
+        end
+      rescue BlueStateDigital::XmlErrorResponse => err
+        begin
+          errors = {}
+          error_xmls = Nokogiri::XML(err.message).xpath('//error')
+          error_xmls.each do |error_xml|
+            field = form_fields.select{|field| field.id.to_s == error_xml.xpath('signup_form_field_id').text}.first
+            errors[field.label] = error_xml.xpath('description').text
+            raise "process_signup failed with errors: #{errors}"
+          end
+        end
+      end
+    end
+
+    def set_cons_group(cons_group_id)
+      connection.perform_request('/signup/set_cons_group', {signup_form_id: self.id}, 'POST', {cons_group_id: cons_group_id})
+    end
+
+    def form_fields
+      if @_form_fields.nil?
+        xml_response = connection.perform_request '/signup/list_form_fields', {signup_form_id: id}, 'GET', nil
+        doc = Nokogiri::XML(xml_response)
+
+        @_form_fields = []
+        doc.xpath('//signup_form_field').each do |form_field_record|
+          @_form_fields << SignupFormField.from_xml(form_field_record)
+        end
+      end
+      @_form_fields
+    end
+  end
+end

data/lib/blue_state_digital/version.rb

@@ -1,3 +1,3 @@
 module BlueStateDigital
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/spec/blue_state_digital/connection_spec.rb

@@ -27,6 +27,46 @@ describe BlueStateDigital::Connection do
     end
   end
 
+  describe '#perform_request_raw' do
+    let(:api_call) { '/somemethod' }
+    let(:timestamp) { Time.now }
+    let(:api_ts) { timestamp.utc.to_i.to_s }
+    let(:api_mac) { connection.compute_hmac("/page/api#{api_call}", api_ts, { api_ver: '2', api_id: api_id, api_ts: api_ts }) }
+
+    describe 'instrumentation' do
+      before(:each) do
+        Timecop.freeze(timestamp) do
+          stub_url = "https://#{api_host}/page/api/somemethod?api_id=#{api_id}&api_mac=#{api_mac}&api_ts=#{api_ts}&api_ver=2"
+          stub_request(:post, stub_url).with do |request|
+            expect(request.body).to eq("a=b")
+            expect(request.headers['Accept']).to eq('text/xml')
+            expect(request.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+            true
+          end.to_return(body: "body")
+        end
+      end
+
+      it 'should not instrument anything if instrumentation is nil' do
+        expect(connection.instrumentation).to be_nil
+        connection.perform_request(api_call, params = {}, method = "POST", body = "a=b")
+      end
+
+      context 'with instrumentation' do
+        let(:instrumentation) do
+          Proc.new do |stats|
+            stats[:path]
+          end
+        end
+        let(:connection) { BlueStateDigital::Connection.new({host: api_host, api_id: api_id, api_secret: api_secret, instrumentation: instrumentation})}
+
+        it 'should call if set to proc' do
+          expect(instrumentation).to receive(:call).with({path: '/page/api/somemethod', :api_id=>"sfrazer"})
+          connection.perform_request(api_call, params = {}, method = "POST", body = "a=b")
+        end
+      end
+    end
+  end
+
   describe "#perform_request" do
     context 'POST' do
       it "should perform POST request" do
@@ -142,6 +182,16 @@ describe BlueStateDigital::Connection do
       expect(connection).to receive(:perform_request).and_return("foo")
       expect(connection.get_deferred_results("deferred_id")).to eq("foo")
     end
+
+    it 'should raise if timeout occurs' do
+       expect(connection).to receive(:perform_request).and_return(nil)
+       expect { connection.wait_for_deferred_result("deferred_id", 1) }.to raise_error(BlueStateDigital::DeferredResultTimeout)
+    end
+
+    it 'should not raise if successful' do
+      expect(connection).to receive(:perform_request).and_return("foo")
+      expect(connection.wait_for_deferred_result("deferred_id")).to eq("foo")
+    end
   end
 
   describe "#compute_hmac" do

data/spec/blue_state_digital/constituent_group_spec.rb

@@ -226,7 +226,7 @@ xml_string
       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})
+      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

data/spec/blue_state_digital/constituent_spec.rb

@@ -254,8 +254,7 @@ describe BlueStateDigital::Constituent do
 
     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)
+        expect(connection).to receive(:perform_request).with('/cons/get_constituents_by_email', {:emails=>"george@washington.com", :bundles => 'cons_group'}, "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')
@@ -263,8 +262,7 @@ describe BlueStateDigital::Constituent do
 
       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)
+        expect(connection).to receive(:perform_request).with('/cons/get_constituents_by_email', {:emails=>"george@washington.com", :bundles => bundles}, "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"
@@ -359,6 +357,7 @@ describe BlueStateDigital::Constituent do
       connection.constituents.delete_constituents_by_id(2)
     end
   end
+
   it "should set constituent data" do
     timestamp = Time.now.to_i
 
@@ -397,7 +396,10 @@ describe BlueStateDigital::Constituent do
     output << "</cons>"
     output << "</api>"
 
-    expect(connection).to receive(:perform_request).with('/cons/set_constituent_data', {}, "POST", input) { output }
+    deferred_result_id = '123'
+
+    expect(connection).to receive(:wait_for_deferred_result).with(deferred_result_id).and_return(output)
+    expect(connection).to receive(:perform_request).with('/cons/upsert_constituent_data', {}, "POST", input) { deferred_result_id }
 
     cons_data = BlueStateDigital::Constituent.new(data)
     cons_data.save
@@ -419,4 +421,4 @@ describe BlueStateDigital::Constituent do
       expect(cons.to_xml).not_to be_nil
     end
   end
-end
+end

data/spec/blue_state_digital/event_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe BlueStateDigital::Event do
-  let(:start_date) { Time.now }
+  let(:time_zone) { Time.find_zone('America/New_York') }
+  let(:start_date) { time_zone.now.change(usec: 0) }
   let(:end_date) { start_date + 1.hour }
-  let(:event_attributes) { {event_type_id: '1', creator_cons_id: '2', name: 'event 1', description: 'my event', venue_name: 'home', venue_country: 'US', venue_zip: '10001', venue_city: 'New York', venue_state_cd: 'NY', start_date: start_date, end_date: end_date} }
+  let(:event_attributes) { {event_type_id: '1', creator_cons_id: '2', name: 'event 1', description: 'my event', venue_name: 'home', venue_country: 'US', venue_zip: '10001', venue_city: 'New York', venue_state_cd: 'NY', start_date: start_date, end_date: end_date, local_timezone: 'America/New_York'} }
 
   describe '#to_json' do
     it "should serialize event without event_id_obfuscated" do
@@ -12,12 +13,12 @@ describe BlueStateDigital::Event do
       event_json = JSON.parse(event.to_json)
 
       expect(event_json.keys).not_to include(:event_id_obfuscated)
-      [:event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd].each do |direct_attribute|
+      [:event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd, :local_timezone].each do |direct_attribute|
         expect(event_json[direct_attribute.to_s]).to eq(event_attributes[direct_attribute])
       end
       expect(event_json['days'].count).to eq(1)
-      start_date = event_json['days'][0]['start_datetime_system']
-      expect(Time.parse(start_date)).to eq(start_date)
+      start_date_serialized = event_json['days'][0]['start_datetime_system']
+      expect(time_zone.parse(start_date_serialized)).to eq(start_date)
       expect(event_json['days'][0]['duration']).to eq(60)
     end
 
@@ -27,12 +28,12 @@ describe BlueStateDigital::Event do
 
       event_json = JSON.parse(event.to_json)
 
-      [:event_id_obfuscated, :event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd].each do |direct_attribute|
+      [:event_id_obfuscated, :event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd, :local_timezone].each do |direct_attribute|
         expect(event_json[direct_attribute.to_s]).to eq(event_attributes[direct_attribute])
       end
       expect(event_json['days'].count).to eq(1)
-      start_date = event_json['days'][0]['start_datetime_system']
-      expect(Time.parse(start_date)).to eq(start_date)
+      start_date_serialized = event_json['days'][0]['start_datetime_system']
+      expect(time_zone.parse(start_date_serialized)).to eq(start_date)
       expect(event_json['days'][0]['duration']).to eq(60)
     end
   end

data/spec/blue_state_digital/signup_form_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe BlueStateDigital::SignupForm do
+  let(:connection) { BlueStateDigital::Connection.new({}) }
+
+  describe '.clone' do
+    it 'should create a new SignupForm' do
+      response = <<-EOF
+        <?xml version="1.0" encoding="utf-8"?>
+        <api>
+          <signup_form>
+            <id>3</id>
+          </signup_form>
+        </api>
+      EOF
+      expect(connection).to receive(:perform_request).with('/signup/clone_form', {}, 'POST',
+                                                           {signup_form_id: 1,
+                                                            title: 'Sign Up Here',
+                                                            signup_form_name: 'Signup Form Foo',
+                                                            slug: 'foo'}).and_return(response)
+
+      form = BlueStateDigital::SignupForm.clone(clone_from_id: 1, slug: 'foo', name: 'Signup Form Foo',
+                                                public_title: 'Sign Up Here', connection: connection)
+      expect(form.id).to eq(3)
+      expect(form.name).to eq('Signup Form Foo')
+      expect(form.slug).to eq('foo')
+      expect(form.public_title).to eq('Sign Up Here')
+    end
+  end
+
+  describe '#process_signup' do
+    let(:signup_form) { BlueStateDigital::SignupForm.new(id: 3, name: 'A Form', slug: 'asdf', public_title: 'The Best Form', connection: connection) }
+    let(:list_form_fields_response) { <<-EOF
+      <?xml version="1.0" encoding="utf-8"?>
+      <api>
+        <signup_form_field id="83">
+          <format>1</format>
+          <label>First Name</label>
+          <description>First Name</description>
+          <display_order>1</display_order>
+          <is_shown>1</is_shown>
+          <is_required>0</is_required>
+          <break_after>0</break_after>
+          <is_custom_field>0</is_custom_field>
+          <cons_field_id>0</cons_field_id>
+          <create_dt>2010-02-08 18:33:11</create_dt>
+          <extra_def></extra_def>
+        </signup_form_field>
+        <signup_form_field id="84">
+          <format>1</format>
+          <label>Last Name</label>
+          <description>Last Name</description>
+          <display_order>2</display_order>
+          <is_shown>1</is_shown>
+          <is_required>0</is_required>
+          <break_after>0</break_after>
+          <is_custom_field>0</is_custom_field>
+          <cons_field_id>0</cons_field_id>
+          <create_dt>2010-02-08 18:33:11</create_dt>
+          <extra_def></extra_def>
+        </signup_form_field>
+      </api>
+    EOF
+    }
+
+    before :each do
+      allow(connection).to receive(:perform_request).with('/signup/list_form_fields',
+                                                          {signup_form_id: signup_form.id},
+                                                          'GET', nil).and_return(list_form_fields_response)
+    end
+
+    it 'should call process_signup' do
+      expected_body_readable = <<-EOF
+        <?xml version="1.0" encoding="utf-8"?>
+        <api>
+          <signup_form id="3">
+            <signup_form_field id="83">Susan</signup_form_field>
+            <signup_form_field id="84">Anthony</signup_form_field>
+            <email_opt_in>1</email_opt_in>
+            <source>foo</source>
+          </signup_form>
+        </api>
+      EOF
+      expected_body = expected_body_readable.squish.gsub('> <', '><')
+
+      expect(connection).to receive(:perform_request_raw).with('/signup/process_signup', {}, 'POST', expected_body).and_return(double(body: '', status: 200))
+
+      signup_data = {'First Name' => 'Susan', 'Middle Initial' => 'B', 'Last Name' => 'Anthony'}
+      signup_form.process_signup(field_data: signup_data, email_opt_in: true, source: 'foo')
+    end
+  end
+
+  describe '#set_cons_group' do
+    let(:signup_form) { BlueStateDigital::SignupForm.new(id: 3, name: 'A Form', slug: 'asdf', public_title: 'The Best Form', connection: connection) }
+    let(:cons_group_id) { 123 }
+
+    it 'should call set_cons_group' do
+      expect(connection).to receive(:perform_request).with('/signup/set_cons_group', {signup_form_id: signup_form.id}, 'POST', {cons_group_id: cons_group_id}).and_return('')
+
+      signup_form.set_cons_group(cons_group_id)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blue_state_digital
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Nathan Woodhull
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-08 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -271,6 +271,7 @@ files:
 - lib/blue_state_digital/event_rsvp.rb
 - lib/blue_state_digital/event_type.rb
 - lib/blue_state_digital/phone.rb
+- lib/blue_state_digital/signup_form.rb
 - lib/blue_state_digital/version.rb
 - spec/blue_state_digital/address_spec.rb
 - spec/blue_state_digital/api_data_model_spec.rb
@@ -286,6 +287,7 @@ files:
 - spec/blue_state_digital/event_spec.rb
 - spec/blue_state_digital/event_type_spec.rb
 - spec/blue_state_digital/phone_spec.rb
+- spec/blue_state_digital/signup_form_spec.rb
 - spec/fixtures/multiple_event_types.json
 - spec/fixtures/single_event_type.json
 - spec/spec_helper.rb
@@ -309,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: blue_state_digital
-rubygems_version: 2.4.8
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Simple wrapper for Blue State Digital.
@@ -328,6 +330,7 @@ test_files:
 - spec/blue_state_digital/event_spec.rb
 - spec/blue_state_digital/event_type_spec.rb
 - spec/blue_state_digital/phone_spec.rb
+- spec/blue_state_digital/signup_form_spec.rb
 - spec/fixtures/multiple_event_types.json
 - spec/fixtures/single_event_type.json
 - spec/spec_helper.rb