mailchimp_api_v3 0.2.17 → 0.2.18

data/spec/mailchimp_api_v3/account_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::Account, vcr: { cassette_name: 'account' } do
-  it 'is the expected class' do
-    expect(Mailchimp.connect.account).to be_a Mailchimp::Account
-  end
-
-  it 'has a name' do
-    expect(Mailchimp.connect.account.name).to eq 'InSite Arts'
-  end
-
-  it 'has an id' do
-    expect(Mailchimp.connect.account.id).to eq '1dbca289fd41b54838bcbb501'
-  end
-end

data/spec/mailchimp_api_v3/client_spec.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::Client, vcr: { cassette_name: 'client' } do
-  context 'unauthorized API key' do
-    let(:bad_key) { 'xxxxxxxxxx-us11' }
-
-    it 'raises an exception if we try to get data' do
-      expect { Mailchimp::Client.new(bad_key).account }.to raise_error Mailchimp::Exception::APIKeyError
-    end
-
-    it 'says it is not connected' do
-      expect(Mailchimp::Client.new(bad_key).connected?).to be_falsey
-    end
-  end
-
-  context 'valid API key' do
-    it 'says it is connected' do
-      expect(Mailchimp::Client.new.connected?).to be_truthy
-    end
-
-    it 'is the expected class' do
-      expect(Mailchimp::Client.new).to be_a Mailchimp::Client
-    end
-
-    it 'has an account method' do
-      expect(Mailchimp::Client.new.account).to be_a Mailchimp::Account
-    end
-
-    it 'has a lists collection' do
-      lists = Mailchimp::Client.new.lists
-      expect(lists).to be_an Array
-      expect(lists.sample).to be_a Mailchimp::List
-    end
-
-    it 'retrieves a list by name' do
-      list = Mailchimp::Client.new.lists 'My first list'
-      expect(list).to be_a Mailchimp::List
-      expect(list.name).to eq 'My first list'
-    end
-
-    it "doesn't respond to everything" do
-      expect(Mailchimp::Client.new.respond_to?(:zzz)).to be_falsey
-    end
-  end
-
-  context 'exceptions' do
-    let(:client) { Mailchimp::Client.new }
-
-    context 'problems we can retry the request for' do
-      it 'eventually raises the exception' do
-        allow(client).to receive(:remote_no_payload).and_raise SocketError.new('test message')
-
-        expect { client.account }.to raise_error { |e|
-          expect(e).to be_a(SocketError)
-          expect(e.message).to eq('test message')
-        }
-      end
-
-      it 'only raises the exception after several retries' do
-        allow(client).to receive(:remote_no_payload).twice.and_raise SocketError.new('test message')
-        allow(client).to receive(:remote_no_payload).and_return '"id":1'
-        expect { client.account }.not_to raise_error
-      end
-    end
-
-    context 'unexpected error' do
-      it 'raises an exception if it encounters an unexpected error' do
-        exception = NotImplementedError.new('test message')
-
-        expect { client.__send__(:managed_remote_exception, exception) }.to raise_error { |e|
-          expect(e).to be_a(NotImplementedError)
-          expect(e.message).to eq('test message')
-        }
-      end
-    end
-  end
-end

data/spec/mailchimp_api_v3/exception_spec.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::Exception::APIKeyError, vcr: { cassette_name: 'exception' } do
-  let(:bad_key) { 'xxxxxxxxxx-us11' }
-
-  it 'raises an exception if the API key is not valid' do
-    expect { Mailchimp.connect(bad_key).account }.to raise_error { |e|
-      expect(e).to be_a Mailchimp::Exception::APIKeyError
-      expect(e.type).to eq 'http://developer.mailchimp.com/documentation/mailchimp/guides/error-glossary/'
-      expect(e.title).to eq 'API Key Invalid'
-      expect(e.status).to eq 401
-      expect(e.detail).to eq 'Your API key may be invalid, or you\'ve attempted to access the wrong datacenter.'
-    }
-  end
-
-  it 'does not raise an exception if the API key is valid' do
-    expect { Mailchimp.connect.account }.not_to raise_error
-  end
-end
-
-describe Mailchimp::Exception::UnknownAttribute, vcr: { cassette_name: 'mailchimp' } do
-  let(:account) { Mailchimp.connect.account }
-
-  it 'returns a known attribute' do
-    expect { account.name }.not_to raise_error
-  end
-
-  it 'fails if we ask for an unknown attribute' do
-    expect { account.blarbleferry }.to raise_error NoMethodError
-  end
-end
-
-describe Mailchimp::Exception::BadRequest do
-  it 'raises a Duplicate exception if the message says so' do
-    data = { 'detail' => 'The thing already exists, idiot' }
-    expect { Mailchimp::Exception.parse_invalid_resource_exception data }
-      .to raise_error Mailchimp::Exception::Duplicate
-  end
-
-  it 'raises a MissingField exception if the message says so' do
-    data = { 'detail' => 'The thing can\'t be blank, idiot' }
-    expect { Mailchimp::Exception.parse_invalid_resource_exception data }
-      .to raise_error Mailchimp::Exception::MissingField
-  end
-
-  it 'raises a BadRequest exception otherwise' do
-    data = { 'detail' => 'The thing is an idiot' }
-    expect { Mailchimp::Exception.parse_invalid_resource_exception data }
-      .to raise_error Mailchimp::Exception::BadRequest
-  end
-
-  it 'responds to everything' do
-    expect(Mailchimp::Exception::BadRequest.new('xxx').respond_to?(:zzz)).to be_truthy
-  end
-end

data/spec/mailchimp_api_v3/interest_categories_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::InterestCategories, vcr: { cassette_name: 'interest_categories' } do
-  let(:list) { Mailchimp.connect.lists.first }
-  let(:interest_categories) { list.interest_categories }
-
-  it 'is the expected class' do
-    expect(interest_categories).to be_a Mailchimp::List::InterestCategories
-  end
-
-  context 'adding and deleting' do
-    context '#create, #find_by, #delete, #first_or_create' do
-      it 'can add and delete a new instance' do
-        title = 'Days'
-        data = { 'title' => title, 'type' => 'checkboxes' }
-
-        # #create
-        expect { interest_categories.create data }.to change { list.interest_categories.count }.by(1)
-        expect { interest_categories.create data }.to raise_error Mailchimp::Exception::Duplicate
-
-        # #find_by
-        interest_category = list.interest_categories.find_by title: title
-        expect(interest_category).to be_a Mailchimp::List::InterestCategory
-        expect(interest_category.title).to eq title
-
-        # #first_or_create finds the same instance
-        interest_category2 = list.interest_categories.first_or_create title: title
-        expect(interest_category.id).to eq(interest_category2.id)
-
-        # #delete
-        expect { interest_category.delete }.to change { list.interest_categories.count }.by(-1)
-
-        # #first_or_create creates a new instance
-        title = 'Sex'
-        data = { 'title' => title, 'type' => 'radio' }
-        interest_category = interest_categories.first_or_create data
-        expect(interest_category.title).to eq title
-      end
-    end
-  end
-end

data/spec/mailchimp_api_v3/interest_category_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::InterestCategory, vcr: { cassette_name: 'interest_category' } do
-  let(:lists) { Mailchimp.connect.lists }
-  let(:list) { lists.first }
-  let(:title) { 'Days' }
-  let(:interest_category) { list.interest_categories.create 'title' => title, 'type' => 'checkboxes' }
-
-  it 'is the expected class' do
-    expect(interest_category).to be_a Mailchimp::List::InterestCategory
-  end
-
-  it 'has a title' do
-    expect(interest_category.title).to eq title
-  end
-
-  it 'has an interests collection' do
-    expect(interest_category.interests.count).to eq 0
-    interest_category.interests.create name: 'Monday'
-    interest_category.interests.create name: 'Tuesday'
-    interests = interest_category.interests
-    expect(interests).to be_an Array
-    expect(interests.sample).to be_a Mailchimp::List::InterestCategory::Interest
-  end
-end

data/spec/mailchimp_api_v3/interest_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::InterestCategory::Interest, vcr: { cassette_name: 'interest' } do
-  let(:lists) { Mailchimp.connect.lists }
-  let(:list) { lists.first }
-  let(:title) { 'Days' }
-  let(:interest_category) { list.interest_categories.create 'title' => title, 'type' => 'checkboxes' }
-  let(:name) { 'Monday' }
-  let(:interest) { interest_category.interests.create name: name }
-
-  it 'is the expected class' do
-    expect(interest).to be_a Mailchimp::List::InterestCategory::Interest
-  end
-
-  it 'has a name' do
-    expect(interest.name).to eq name
-  end
-
-  it 'deletes an instance' do
-    interest2 = interest_category.interests.create name: 'Tuesday'
-    expect { interest2.delete }.to change { interest_category.interests.count }.by(-1)
-  end
-end

data/spec/mailchimp_api_v3/interests_spec.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::InterestCategory::Interests, vcr: { cassette_name: 'interests' } do
-  let(:list) { Mailchimp.connect.lists.first }
-  let(:title) { 'Days' }
-  let(:interest_category) { list.interest_categories.create 'title' => title, 'type' => 'checkboxes' }
-  let(:interests) { interest_category.interests }
-
-  it 'is the expected class' do
-    expect(interests).to be_a Mailchimp::List::InterestCategory::Interests
-  end
-
-  context 'adding and deleting' do
-    context '#create, #find_by, #delete, #first_or_create' do
-      it 'can add and delete a new instance' do
-        name = 'Monday'
-        data = { 'name' => name }
-
-        # #create
-        expect { interests.create data }.to change { interest_category.interests.count }.by(1)
-        expect { interests.create data }.to raise_error Mailchimp::Exception::Duplicate
-
-        # #find_by
-        interest = interest_category.interests.find_by name: name
-        expect(interest).to be_a Mailchimp::List::InterestCategory::Interest
-        expect(interest.name).to eq name
-
-        # #first_or_create finds the same instance
-        interest2 = interest_category.interests.first_or_create name: name
-        expect(interest.id).to eq(interest2.id)
-
-        # #delete
-        expect { interest.delete }.to change { interest_category.interests.count }.by(-1)
-
-        # #first_or_create creates a new instance
-        name = 'Tuesday'
-        data = { 'name' => name }
-        interest = interests.first_or_create data
-        expect(interest.name).to eq name
-      end
-    end
-  end
-end

data/spec/mailchimp_api_v3/list_spec.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List, vcr: { cassette_name: 'list' } do
-  let(:lists) { Mailchimp.connect.lists }
-  let(:list) { lists.first }
-
-  it 'is the expected class' do
-    expect(list).to be_a Mailchimp::List
-  end
-
-  it 'has a name' do
-    expect(list.name).to eq 'My first list'
-  end
-
-  it 'has an id' do
-    expect(list.id).to eq 'e73f5910ca'
-  end
-
-  it 'has an id + name method' do
-    expect(list.id_and_name).to eq 'e73f5910ca___My first list'
-  end
-
-  it 'has a members collection' do
-    members = list.members
-    expect(members).to be_an Array
-    expect(members.sample).to be_a Mailchimp::List::Member
-  end
-
-  it 'gets a subset of members' do
-    members = list.members last_name: 'Example'
-    expect(members).to be_an Array
-    expect(members.sample).to be_a Mailchimp::List::Member
-  end
-
-  it 'has a interest_categories collection' do
-    interest_categories = list.interest_categories
-    expect(interest_categories).to be_an Array
-    expect(interest_categories.sample).to be_a Mailchimp::List::InterestCategory
-  end
-
-  context 'get a specific member' do
-    let(:email_address) { 'ann@sayers.cc' }
-    let(:id) { '140b91c107d2058dee730e75be0b1151' }
-
-    it 'gets a member by id' do
-      member = list.members id
-      expect(member).to be_a Mailchimp::List::Member
-      expect(member.id).to eq id
-      expect(member.email_address).to eq email_address
-    end
-
-    it 'gets a member by email address' do
-      member = list.members email_address
-      expect(member).to be_a Mailchimp::List::Member
-      expect(member.id).to eq id
-      expect(member.email_address).to eq email_address
-    end
-
-    it 'gets a member by name' do
-      member = list.members 'William Bonkers'
-      expect(member).to be_a Mailchimp::List::Member
-      expect(member.id).to eq id
-    end
-  end
-end

data/spec/mailchimp_api_v3/lists_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::Lists, vcr: { cassette_name: 'lists' } do
-  let(:lists) { Mailchimp.connect.lists }
-
-  it 'is the expected class' do
-    expect(lists).to be_a Mailchimp::Lists
-  end
-
-  it 'has a count' do
-    expect(lists.count).to eq 4
-  end
-
-  it 'returns a list by id' do
-    expect(Mailchimp.connect.lists('aa923b0da6')).to be_a Mailchimp::List
-  end
-
-  it 'handles a non-existent id' do
-    expect(Mailchimp.connect.lists('beef')).to be_nil
-  end
-end

data/spec/mailchimp_api_v3/member_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::Member, vcr: { cassette_name: 'member' } do
-  let(:lists) { Mailchimp.connect.lists }
-  let(:list) { lists.first }
-  let(:name) { 'Ann Example' }
-  let(:member) { list.members.first_or_create name: name, email_address: 'ann@sayers.cc' }
-
-  it 'is the expected class' do
-    expect(member).to be_a Mailchimp::List::Member
-  end
-
-  it 'has a name' do
-    expect(member.name).to eq name
-  end
-
-  it 'has a string repsentation' do
-    expect(member.to_s).to eq 'Ann Example <ann@sayers.cc>'
-  end
-
-  it 'handles unexpected data' do
-    expect { list.members.create(0) }.to raise_error(
-      Mailchimp::Exception::BadRequest, 'Expecting a Hash, received a Integer: 0'
-    )
-  end
-
-  it 'matches supplied comparison data' do
-    expect(member.matches?(name: name, email_address: 'ann@sayers.cc')).to be_truthy
-  end
-
-  it "doesn't match mismatched comparison data" do
-    expect(member.matches?(name: name, vip: true)).to be_falsey
-  end
-
-  context 'updates name fields correctly' do
-    it 'uses friendly name fields' do
-      updated_member = member.update name: 'Billy Bonkers'
-      expect(updated_member).to be_a Mailchimp::List::Member
-      expect(updated_member).to have_attributes name: 'Billy Bonkers'
-
-      updated_member = updated_member.update first_name: 'William'
-      expect(updated_member).to have_attributes name: 'William Bonkers'
-    end
-
-    it 'handles multiple definitions of the same field' do
-      data = {
-        name: 'Billy Bonkers',
-        first_name: 'William',
-        merge_fields: {
-          FNAME: 'Ann',
-          LNAME: 'Example'
-        }
-      }
-
-      expect(member.update(data)).to have_attributes name: 'Ann Example'
-    end
-  end
-end

data/spec/mailchimp_api_v3/members_spec.rb

@@ -1,132 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-describe Mailchimp::List::Members do
-  context 'paging', vcr: { cassette_name: 'members_paging', allow_playback_repeats: true } do
-    let(:page_size) { 10 }
-    let(:member_count) { 19 }
-    let(:list) { Mailchimp.connect.lists 'API test list' }
-    let(:members) { list.members 'page_size' => page_size }
-
-    it 'is the expected class' do
-      expect(members).to be_a Mailchimp::List::Members
-    end
-
-    it 'has a count' do
-      expect(members.count).to eq member_count
-    end
-
-    it 'returns pages of members' do
-      counts = []
-      members.find_in_pages { |p| counts << p.count }
-      expect(counts).to eq [page_size, 9]
-    end
-
-    it 'returns all members by paging' do
-      count = 0
-      members.find_each { |_| count += 1 }
-      expect(count).to eq member_count
-    end
-
-    it 'has a Member for each item' do
-      expect(members.sample).to be_a Mailchimp::List::Member
-    end
-  end
-
-  context 'adding and deleting' do
-    context '#create, #find_by, #delete, #first_or_create', vcr: { cassette_name: 'members' } do
-      let(:list) { Mailchimp.connect.lists 'My first list' }
-      let(:members) { list.members }
-
-      it 'can add and delete a new instance' do
-        name = 'Cat Sayers'
-        data = { name: name, email_address: 'cat@sayers.cc', status: 'subscribed' }
-
-        # #create
-        expect { members.create data }.to change { list.members.count }.by(1)
-        expect { members.create data }.to raise_error Mailchimp::Exception::Duplicate
-
-        # #find_by
-        member = list.members.find_by name: name
-        expect(member).to be_a Mailchimp::List::Member
-        expect(member.name).to eq name
-
-        # #first_or_create finds the same instance
-        member2 = list.members.first_or_create name: name
-        expect(member.id).to eq(member2.id)
-
-        # #delete
-        expect { member.delete }.to change { list.members.count }.by(-1)
-
-        # #first_or_create creates a new instance
-        name = 'Dan Sayers'
-        data = { name: name, email_address: 'dan@sayers.cc', status: 'subscribed' }
-        member = members.first_or_create data
-        expect(member.name).to eq name
-        member.delete # Tidy up
-      end
-    end
-
-    context '#first_or_create with interest categories', vcr: { cassette_name: 'members_with_interest_categories' } do
-      let(:list) { Mailchimp.connect.lists 'My first list' }
-      let(:members) { list.members }
-      let(:interest_categories) { list.interest_categories }
-
-      before do
-        data = { 'title' => 'Days', 'type' => 'checkboxes' }
-        interest_categories.create data
-      end
-
-      it 'can add and delete a new instance' do
-        name = 'Cat Sayers'
-        interests = { interest_categories.first.id => true }
-        data = { name: name, email_address: 'cat@sayers.cc', status: 'subscribed', interests: interests }
-
-        # #create
-        expect { members.create data }.to change { list.members.count }.by(1)
-        expect { members.create data }.to raise_error Mailchimp::Exception::Duplicate
-
-        # #find_by
-        member = list.members.find_by name: name
-        expect(member).to be_a Mailchimp::List::Member
-        expect(member.name).to eq name
-
-        # #first_or_create finds the same instance
-        member2 = list.members.first_or_create data
-        expect(member.id).to eq(member2.id)
-
-        # #delete
-        expect { member.delete }.to change { list.members.count }.by(-1)
-
-        # #first_or_create creates a new instance
-        name = 'Dan Sayers'
-        data = { name: name, email_address: 'dan@sayers.cc', status: 'subscribed' }
-        member = members.first_or_create data
-        expect(member.name).to eq name
-        member.delete # Tidy up
-      end
-    end
-
-    context '#create_or_update', vcr: { cassette_name: 'members_create_or_update' } do
-      let(:list) { Mailchimp.connect.lists 'My first list' }
-      let(:members) { list.members }
-
-      it 'creates when no match is found, updates otherwise' do
-        name = 'Cat Sayers'
-        data = { name: name, email_address: 'cat@sayers.cc', status: 'subscribed' }
-
-        # Create
-        expect { members.create_or_update data }.to change { list.members.count }.by(1)
-
-        # Update
-        data = { first_name: 'Catherine', email_address: 'cat@sayers.cc', status: 'subscribed' }
-        expect { members.create_or_update data }.not_to change { list.members.count }
-        expect(members.create_or_update(data)).to have_attributes name: 'Catherine Sayers'
-
-        # Unless we supply an id or equivalent, we won't end up updating anything
-        data = { name: 'Catherine Sayers' }
-        expect { members.create_or_update data }.not_to change { list.members.count }
-        expect(members.create_or_update(data)).to have_attributes name: 'Catherine Sayers'
-      end
-    end
-  end
-end