signal_api 0.0.1

data/test/api/contact_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+require 'signal_api/mocks/contact'
+
+class ContactTest < Test::Unit::TestCase
+
+  def setup
+    SignalApi.api_key = 'foobar'
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = true
+  end
+
+  should "be able to save a contact with lots of info" do
+    contact = SignalApi::Contact.new('mobile_phone' => '3125551212', 'email_address' => 'bill.johnson@domain.com', 'first_name' => 'bill', 'last_name' => 'johnson', 'zip_code' => '60606')
+    contact.save
+
+    attributes = SignalApi::Contact.mock_method_calls[:save].last[:attributes]
+    assert_equal '3125551212', attributes['mobile_phone']
+    assert_equal 'bill.johnson@domain.com', attributes['email_address']
+    assert_equal 'bill', attributes['first_name']
+    assert_equal 'johnson', attributes['last_name']
+    assert_equal '60606', attributes['zip_code']
+  end
+
+  should "be able to save a contact with mobile_phone and email" do
+    contact = SignalApi::Contact.new('mobile_phone' => '3125551212', 'email_address' => 'bill.johnson@domain.com')
+    contact.save
+
+    attributes = SignalApi::Contact.mock_method_calls[:save].last[:attributes]
+    assert_equal '3125551212', attributes['mobile_phone']
+    assert_equal 'bill.johnson@domain.com', attributes['email_address']
+  end
+
+
+  should "be able to save a contact with mobile_phone and something else" do
+    contact = SignalApi::Contact.new('mobile_phone' => '3125551212', 'first_name' => 'bill')
+    contact.save
+
+    attributes = SignalApi::Contact.mock_method_calls[:save].last[:attributes]
+    assert_equal '3125551212', attributes['mobile_phone']
+    assert_equal 'bill', attributes['first_name']
+  end
+
+  should "be able to save a contact with email and something else" do
+    contact = SignalApi::Contact.new('email_address' => 'bill.johnson@domain.com', 'first_name' => 'bill')
+    contact.save
+
+    attributes = SignalApi::Contact.mock_method_calls[:save].last[:attributes]
+    assert_equal 'bill.johnson@domain.com', attributes['email_address']
+    assert_equal 'bill', attributes['first_name']
+  end
+
+  should "should throw exceptions no parms" do
+    contact = SignalApi::Contact.new()
+
+    assert_raise SignalApi::InvalidParameterException do
+      contact.send(:validate_contact_update)
+    end
+  end
+
+  should "should throw exceptions one parm not mobile_phone or email" do
+    contact = SignalApi::Contact.new('first_name' => 'bill')
+
+    assert_raise SignalApi::InvalidParameterException do
+      contact.send(:validate_contact_update)
+    end
+  end
+
+  should "should throw exceptions one parm mobile_phone or email" do
+    contact = SignalApi::Contact.new('mobile_phone' => '3125551212')
+
+    assert_raise SignalApi::InvalidParameterException do
+      contact.send(:validate_contact_update)
+    end
+    contact = SignalApi::Contact.new('email_address' => 'bill.johnson@domain.com')
+
+    assert_raise SignalApi::InvalidParameterException do
+      contact.send(:validate_contact_update)
+    end
+  end
+
+  should "should throw exceptions two parms no mobile_phone or email" do
+    contact = SignalApi::Contact.new('first_name' => 'bill', 'last_name' => 'johnson')
+
+    assert_raise SignalApi::InvalidParameterException do
+      contact.send(:validate_contact_update)
+    end
+  end
+
+end

data/test/api/coupon_group_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class CouponGroupTest < Test::Unit::TestCase
+
+  def setup
+    SignalApi.api_key = 'foobar'
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = true
+  end
+
+  should "be able to consume a coupon given a tag and phone number" do
+    body = <<-END
+<?xml version="1.0" encoding="UTF-8"?>
+<coupon_code>AB1234</coupon_code>
+END
+
+    FakeWeb.register_uri(:get, SignalApi.base_uri + '/api/coupon_groups/consume_coupon.xml', :content_type => 'application/xml', :status => ['200', 'Ok'], :body => body)
+    coupon_code = SignalApi::CouponGroup.consume_coupon("tag", "6843456782")
+    assert_equal "AB1234", coupon_code
+  end
+
+  should "should throw exceptions for missing params" do
+    assert_raise SignalApi::InvalidParameterException do
+      SignalApi::CouponGroup.consume_coupon(nil, "3125551212")
+    end
+
+    assert_raise SignalApi::InvalidParameterException do
+      SignalApi::CouponGroup.consume_coupon("asdfa", nil)
+    end
+  end
+
+end

data/test/api/deliver_sms_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class DeliverSmsTest < Test::Unit::TestCase
+
+  def setup
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = true
+  end
+
+  should "be able to send a SMS message" do
+    FakeWeb.register_uri(:post, uri, :status => ['200', 'Success'], :body => "Message ID: 7f9e82c0efbc012a166c0030482ef624")
+    deliver_sms = SignalApi::DeliverSms.new('joe', 'joepassword')
+    message_id = deliver_sms.deliver('3125551212', 'This is a test message')
+    assert_equal "7f9e82c0efbc012a166c0030482ef624", message_id
+  end
+
+  should "handle API failures" do
+    FakeWeb.register_uri(:post, uri, :status => ['500', 'Server Error'], :body => "Something bad happened")
+    deliver_sms = SignalApi::DeliverSms.new('joe', 'joepassword')
+    assert_raise SignalApi::ApiException do
+      message_id = deliver_sms.deliver('3125551212', 'This is a test message')
+    end
+  end
+
+  should "raise an error if the message is blank" do
+    deliver_sms = SignalApi::DeliverSms.new('joe', 'joepassword')
+    exception = assert_raise SignalApi::InvalidParameterException do
+      deliver_sms.deliver('3125551212', nil)
+    end
+    assert_equal "A message must be provided", exception.message
+  end
+
+  should "raise an error if the mobile phone is blank" do
+    deliver_sms = SignalApi::DeliverSms.new('joe', 'joepassword')
+    exception = assert_raise SignalApi::InvalidParameterException do
+      deliver_sms.deliver(nil, 'This is a test message')
+    end
+    assert_equal "An invalid mobile phone was specified: ", exception.message
+  end
+
+  should "raise an error if the mobile phone is invalid" do
+    deliver_sms = SignalApi::DeliverSms.new('joe', 'joepassword')
+    exception = assert_raise SignalApi::InvalidParameterException do
+      deliver_sms.deliver("foo", 'This is a test message')
+    end
+    assert_equal "An invalid mobile phone was specified: foo", exception.message
+  end
+
+  should "raise an error if the username and password were not specified" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      SignalApi::DeliverSms.new('joe', nil)
+    end
+    assert_equal "username and password must be provided", exception.message
+  end
+
+  private
+
+  def uri
+    %r|https://joe:joepassword@api.imws.us/messages/send|
+  end
+
+end

data/test/api/general_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ShortUrlTest < Test::Unit::TestCase
+
+  should "raise an exception if the api_key is nil" do
+    SignalApi.api_key = nil
+    assert_raise SignalApi::InvalidApiKeyException do
+      SignalApi::ShortUrl.create("http://www.google.com", "ix.ly")
+    end
+  end
+
+  should "raise an exception if the api_key is blank" do
+    SignalApi.api_key = '   '
+    assert_raise SignalApi::InvalidApiKeyException do
+      SignalApi::ShortUrl.create("http://www.google.com", "ix.ly")
+    end
+  end
+
+  should "raise an exception if authentication failed" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/short_urls.xml', :content_type => 'application/xml', :status => ['401', 'Unauthorized'])
+    assert_raise SignalApi::AuthFailedException do
+      short_url = SignalApi::ShortUrl.create("http://www.google.com", "ix.ly")
+    end
+  end
+
+end

data/test/api/list_test.rb

@@ -0,0 +1,261 @@
+require 'test_helper'
+
+class ListTest < Test::Unit::TestCase
+
+  def setup
+    SignalApi.api_key = 'foobar'
+    FakeWeb.allow_net_connect = false
+
+    @list = SignalApi::List.new(1)
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = true
+  end
+
+  should "not be able to create a List with a nil list id" do
+    assert_raise SignalApi::InvalidParameterException do
+      SignalApi::List.new(nil)
+    end
+  end
+
+  #
+  # create_subscription
+  #
+  should "raise an error if trying to create a subscription with an invalid subscription type" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.create_subscription("foo", SignalApi::Contact.new)
+    end
+    assert_equal "Invalid subscription type", exception.message
+  end
+
+  should "raise an error if calling create_subscription and no contact was provided" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.create_subscription(SignalApi::SubscriptionType::SMS, nil)
+    end
+    assert_equal "A contact must be provided", exception.message
+  end
+
+  should "not be able to create a SMS subscription without a mobile phone number" do
+    exception = assert_raise SignalApi::InvalidMobilePhoneException do
+      @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('first-name' => 'John'))
+    end
+    assert_equal "A valid mobile phone number required for SMS subscriptions", exception.message
+  end
+
+  should "not be able to create a SMS subscription with an invalid mobile phone number" do
+    exception = assert_raise SignalApi::InvalidMobilePhoneException do
+      @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '1234', 'first-name' => 'John'))
+    end
+    assert_equal "A valid mobile phone number required for SMS subscriptions", exception.message
+  end
+
+  should "not be able to create an email subscription without an email address" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.create_subscription(SignalApi::SubscriptionType::EMAIL, SignalApi::Contact.new('first-name' => 'John'))
+    end
+    assert_equal "A valid email address required for EMAIL subscriptions", exception.message
+  end
+
+  should "not be able to create an email subscription with an invalid email address" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.create_subscription(SignalApi::SubscriptionType::EMAIL, SignalApi::Contact.new('email-address' => 'foo', 'first-name' => 'John'))
+    end
+    assert_equal "A valid email address required for EMAIL subscriptions", exception.message
+  end
+
+  should "be able to create a new subscription" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions.xml', :status => ['200', 'Success'])
+    @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+  end
+
+  should "returns false if the subscription could not be created" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/subscriptions.xml</request>
+  <message>You are already signed up to the TEST mobile subscription list. To opt-out, send the text message 'STOP TEST' to 839863.</message>
+</error>
+END
+    assert_equal false, @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+  end
+
+  should "returns false if the subscription could not be created because of recent unsubscribe" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/subscriptions.xml</request>
+  <message>Subscriber cannot be re-added since they have unsubscribed within the past 30 days</message>
+</error>
+END
+    assert_equal false, @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+  end
+
+  should "returns false if the subscription already exists but was unconfirmed" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/subscriptions.xml</request>
+  <message>User already subscribed, resending confirmation message: to confirm reply y</message>
+</error>
+END
+    assert_equal false, @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+  end
+
+  should "raise an exception if the subscription could not be created due to invalid mobile" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/subscriptions.xml</request>
+  <message>Could not find the carrier for mobile phone 3125551212</message>
+</error>
+END
+    assert_raise SignalApi::InvalidMobilePhoneException do
+      @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+    end
+  end
+
+  should "not retry the request if it failed because the mobile phone is invalid" do
+    begin
+      SignalApi.retries = 3
+      response = stub(:code => 422, :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/subscriptions.xml</request>
+  <message>Could not find the carrier for mobile phone 3125551212</message>
+</error>
+END
+      SignalApi::List.expects(:post).returns(response).once
+      assert_raise SignalApi::InvalidMobilePhoneException do
+        @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'), :source_keyword => 'FOO')
+      end
+    ensure
+      SignalApi.retries = 0
+    end
+  end
+
+  #
+  # destroy_subscription
+  #
+  should "raise an error if trying to destroy a subscription with an invalid subscription type" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.destroy_subscription("foo", SignalApi::Contact.new)
+    end
+    assert_equal "Invalid subscription type", exception.message
+  end
+
+  should "raise an error if calling destroy_subscription andno contact was provided" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.destroy_subscription(SignalApi::SubscriptionType::SMS, nil)
+    end
+    assert_equal "A contact must be provided", exception.message
+  end
+
+  should "not be able to destroy an SMS subscription without a mobile phone number" do
+    exception = assert_raise SignalApi::InvalidMobilePhoneException do
+      @list.destroy_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('first-name' => 'John'))
+    end
+    assert_equal "A valid mobile phone number required for SMS subscriptions", exception.message
+  end
+
+  should "not be able to destroy an SMS subscription with an invalid mobile phone number" do
+    exception = assert_raise SignalApi::InvalidMobilePhoneException do
+      @list.create_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '1234', 'first-name' => 'John'))
+    end
+    assert_equal "A valid mobile phone number required for SMS subscriptions", exception.message
+  end
+
+  should "not be able to destroy an email subscription without an email address" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.destroy_subscription(SignalApi::SubscriptionType::EMAIL, SignalApi::Contact.new('first-name' => 'John'))
+    end
+    assert_equal "A valid email address required for EMAIL subscriptions", exception.message
+  end
+
+  should "not be able to destroy an email subscription with an invalid email address" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.destroy_subscription(SignalApi::SubscriptionType::EMAIL, SignalApi::Contact.new('email-address' => 'foo', 'first-name' => 'John'))
+    end
+    assert_equal "A valid email address required for EMAIL subscriptions", exception.message
+  end
+
+  should "be able to destroy a subscription" do
+    FakeWeb.register_uri(:delete, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions/3125551212.xml', :status => ['200', 'Success'])
+    @list.destroy_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'))
+  end
+
+  should "return false if the subscription could not be destroyed because user not subscribed" do
+    FakeWeb.register_uri(:delete, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions/3125551212.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/3125551212.xml</request>
+  <message>3125551212 is not subscribed to campaign ID 1</message>
+</error>
+END
+    assert_equal false, @list.destroy_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'))
+  end
+
+  should "return false if the subscription could not be destroyed because invalid user" do
+    FakeWeb.register_uri(:delete, SignalApi.base_uri + '/api/subscription_campaigns/1/subscriptions/3125551212.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/3125551212.xml</request>
+  <message>Invalid user ID: 3125551212</message>
+</error>
+END
+    assert_equal false, @list.destroy_subscription(SignalApi::SubscriptionType::SMS, SignalApi::Contact.new('mobile-phone' => '3125551212', 'first-name' => 'John'))
+  end
+
+  #
+  # send_message
+  #
+  should "raise an error if trying to send a mesasge without a description" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.send_message(nil, "This is the message")
+    end
+    assert_equal "A description must be provided", exception.message
+  end
+
+  should "raise an error if trying to send a mesasge without a message" do
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.send_message("This is the description", "")
+    end
+    assert_equal "A text message must be provided", exception.message
+  end
+
+  should "raise an error if trying to send a mesasge greater than 160 characters" do
+    message = 161.times.inject("") { |msg, i| msg << "a" }
+    exception = assert_raise SignalApi::InvalidParameterException do
+      @list.send_message("This is the description", message)
+    end
+    assert_equal "The text message must not be greater than 160 characters", exception.message
+  end
+
+  should "be able to send a message to a subscription list" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/send_message.xml', :status => ['200', 'Success'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<scheduled-message>
+  <id type="integer">101</id>
+</scheduled-message>
+END
+    message_id = @list.send_message("Some description", "A message", :send_at => Time.local(2012, 4, 17, 10, 05, 07), :segment_id => 7, :tags => [1, 2],
+                                    :carrier_overrides => [SignalApi::CarrierOverrideMessage.new(2, "some override message")])
+    assert_equal 101, message_id
+  end
+
+  should "raise an exception if unable to send the message successfully" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/subscription_campaigns/1/send_message.xml', :status => ['422', 'Bad Request'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>/api/subscription_campaigns/1/send_message.xml</request>
+  <message>No segment could be found with an id of 404</message>
+</error>
+END
+    assert_raise SignalApi::ApiException do
+      @list.send_message("Some description", "A message", :send_at => Time.local(2012, 4, 17, 10, 05, 07), :segment_id => 404,
+                         :carrier_overrides => [SignalApi::CarrierOverrideMessage.new(2, "some override message")])
+    end
+  end
+
+end

data/test/api/segment_test.rb

@@ -0,0 +1,144 @@
+require 'test_helper'
+
+class SegmentTest < Test::Unit::TestCase
+
+  def setup
+    SignalApi.api_key = 'foobar'
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = true
+  end
+
+  #
+  # SegmentUser
+  #
+  should "raise an error if trying to create a SegmentUser with an identifying attribute that is not a mobile phone number or email address" do
+    assert_raise SignalApi::InvalidParameterException do
+      SignalApi::SegmentUser.new("foo")
+    end
+  end
+
+  should "be able to create a SegmentUser with a mobile phone and user data" do
+    segment_user = SignalApi::SegmentUser.new("3125551212", :foo_1 => 'bar_1', :foo_2 => 'bar_2')
+    assert_equal "3125551212", segment_user.mobile_phone
+    assert_equal Hash[:foo_1 => 'bar_1', :foo_2 => 'bar_2'], segment_user.user_data
+  end
+
+  should "be able to create a SegmentUser with an email address and user data" do
+    segment_user = SignalApi::SegmentUser.new("john@test.com", :foo_1 => 'bar_1', :foo_2 => 'bar_2')
+    assert_equal "john@test.com", segment_user.email_address
+    assert_equal Hash[:foo_1 => 'bar_1', :foo_2 => 'bar_2'], segment_user.user_data
+  end
+
+  #
+  # create
+  #
+  should "raise an error if any of the required parameters are missing" do
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create(nil, "description", SignalApi::SegmentType::STATIC) }
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create("", "description", SignalApi::SegmentType::STATIC) }
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create("name", nil, SignalApi::SegmentType::STATIC) }
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create("name", "", SignalApi::SegmentType::STATIC) }
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create("name", "description", nil) }
+  end
+
+  should "raise an exception if an invalid segment type is provided" do
+    assert_raise(SignalApi::InvalidParameterException) { SignalApi::Segment.create("name", "description", "foo") }
+  end
+
+  should "be able to create a segment" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/filter_groups/create.xml', :content_type => 'application/xml', :status => ['200', 'Success'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<subscription-list-filter-group>
+  <name>Segment 1</name>
+  <created-at type="datetime">2012-04-13T18:58:50Z</created-at>
+  <updated-at type="datetime">2012-04-13T18:58:50Z</updated-at>
+  <account-id type="integer">1</account-id>
+  <id type="integer">25</id>
+  <filter-group-type-id type="integer">2</filter-group-type-id>
+  <description>Test segment 1</description>
+  <blast-only type="boolean">false</blast-only>
+  <active type="boolean">true</active>
+</subscription-list-filter-group>
+END
+    segment = SignalApi::Segment.create("Segment 1", "Test segment 1", SignalApi::SegmentType::STATIC)
+    assert_equal 25, segment.id
+    assert_equal "Segment 1", segment.name
+    assert_equal "Test segment 1", segment.description
+    assert_equal SignalApi::SegmentType::STATIC, segment.segment_type
+    assert_equal 1, segment.account_id
+  end
+
+  should "raise an exception if unable to create the segment" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/filter_groups/create.xml', :content_type => 'application/xml', :status => ['422', 'Unprocessable Entity'], :body => <<-END)
+<errors><error>name^A filter group with this name already exists</error></errors>
+END
+    assert_raise SignalApi::ApiException do
+      SignalApi::Segment.create("Segment 1", "Test segment 1", SignalApi::SegmentType::STATIC)
+    end
+  end
+
+  #
+  # add_users
+  #
+  should "raise an error if no segment users were passed in" do
+    assert_raise SignalApi::InvalidParameterException do
+      segment = SignalApi::Segment.new(1)
+      segment.add_users(nil)
+    end
+  end
+
+  should "be able to add a collection of segment users to a static segment" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/filter_segments/1/update.xml', :content_type => 'application/xml', :status => ['200', 'Success'], :body => <<-END)
+<subscription_list_segment_results>
+  <users_not_found>
+    <user_not_found>user with email john@test.com not found</user_not_found>
+    <user_not_found>user with email bill@test.com not found</user_not_found>
+  </users_not_found>
+  <total_users_processed>4</total_users_processed>
+  <total_users_added>2</total_users_added>
+  <total_users_not_found>2</total_users_not_found>
+  <total_duplicate_users>0</total_duplicate_users>
+</subscription_list_segment_results>
+END
+
+    segment_users = [
+      SignalApi::SegmentUser.new("3125551212", :foo_1 => 'bar 1', :foo_2 => 'bar 2'),
+      SignalApi::SegmentUser.new("john@test.com", :foo_3 => 'bar 3', :foo_4 => 'bar 4'),
+      SignalApi::SegmentUser.new("3125551213"),
+      SignalApi::SegmentUser.new("bill@test.com")
+    ]
+
+    segment = SignalApi::Segment.new(1)
+    results = segment.add_users(segment_users)
+    assert_equal 2, results[:total_users_added]
+    assert_equal 2, results[:total_users_not_found]
+    assert_equal 0, results[:total_duplicate_users]
+    assert_equal 4, results[:total_users_processed]
+  end
+
+  should "raise an exception if unable to add users to the segment" do
+    FakeWeb.register_uri(:post, SignalApi.base_uri + '/api/filter_segments/1/update.xml', :content_type => 'application/xml', :status => ['422', 'Success'], :body => <<-END)
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <request>http://textme.dev/api/filter_segments/63/update.xml</request>
+  <message>trying access invalid filter group</message>
+</error>
+END
+
+    segment_users = [
+      SignalApi::SegmentUser.new("3125551212", :foo_1 => 'bar 1', :foo_2 => 'bar 2'),
+      SignalApi::SegmentUser.new("john@test.com", :foo_3 => 'bar 3', :foo_4 => 'bar 4'),
+      SignalApi::SegmentUser.new("3125551213"),
+      SignalApi::SegmentUser.new("bill@test.com")
+    ]
+
+    segment = SignalApi::Segment.new(1)
+    assert_raise SignalApi::ApiException do
+      segment.add_users(segment_users)
+    end
+  end
+
+end