customerio 2.2.1 → 4.0.1

data/lib/customerio/regions.rb

@@ -0,0 +1,11 @@
+require 'net/http'
+require 'multi_json'
+
+module Customerio
+  module Regions
+    Region = Struct.new(:track_url, :api_url)
+
+    US = Customerio::Regions::Region.new('https://track.customer.io', 'https://api.customer.io').freeze
+    EU = Customerio::Regions::Region.new('https://track-eu.customer.io', 'https://api-eu.customer.io').freeze
+  end
+end

data/lib/customerio/requests/send_email_request.rb

@@ -0,0 +1,49 @@
+require 'base64'
+
+module Customerio
+  class SendEmailRequest
+    attr_reader :message
+
+    def initialize(opts)
+      @message = opts.delete_if { |field| invalid_field?(field) }
+      @message[:attachments] = {}
+      @message[:headers] = {}
+    end
+
+    def attach(name, data, encode: true)
+      raise "attachment #{name} already exists" if @message[:attachments].has_key?(name)
+      @message[:attachments][name] = encode ? Base64.strict_encode64(data) : data
+    end
+
+    private
+
+    REQUIRED_FIELDS = %i(to identifiers)
+
+    OPTIONAL_FIELDS = %i(
+      transactional_message_id
+      message_data
+      headers
+      preheader
+      from
+      reply_to
+      bcc
+      subject
+      body
+      plaintext_body
+      amp_body
+      fake_bcc
+      disable_message_retention
+      send_to_unsubscribed
+      tracked
+      queue_draft
+    )
+
+    def invalid_field?(field)
+      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    end
+
+    def encode(data)
+      Base64.strict_encode64(data)
+    end
+  end
+end

data/lib/customerio/version.rb

@@ -1,3 +1,3 @@
 module Customerio
-  VERSION = "2.2.1"
+  VERSION = "4.0.1"
 end

data/spec/api_client_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+require 'multi_json'
+require 'base64'
+require 'tempfile'
+
+describe Customerio::APIClient do
+  let(:app_key) { "appkey" }
+
+  let(:client)   { Customerio::APIClient.new(app_key) }
+  let(:response) { double("Response", code: 200) }
+
+  def api_uri(path)
+    "https://api.customer.io#{path}"
+  end
+
+  def request_headers
+    { 'Authorization': "Bearer #{app_key}", 'Content-Type': 'application/json' }
+  end
+
+  def json(data)
+    MultiJson.dump(data)
+  end
+
+  it "the base client is initialised with the correct values when no region is passed in" do
+    app_key = "appkey"
+
+    expect(Customerio::BaseClient).to(
+      receive(:new)
+        .with(
+          { app_key: app_key },
+          {
+            region: Customerio::Regions::US,
+            url: Customerio::Regions::US.api_url
+          }
+        )
+    )
+
+    client = Customerio::APIClient.new(app_key)
+  end
+
+  it "raises an error when an incorrect region is passed in" do
+    expect {
+      Customerio::APIClient.new("appkey", region: :au)
+    }.to raise_error /region must be an instance of Customerio::Regions::Region/
+  end
+
+  [Customerio::Regions::US, Customerio::Regions::EU].each do |region|
+    it "the base client is initialised with the correct values when the region \"#{region}\" is passed in" do
+      app_key = "appkey"
+
+      expect(Customerio::BaseClient).to(
+        receive(:new)
+          .with(
+            { app_key: app_key },
+            {
+              region: region,
+              url: region.api_url
+            }
+          )
+      )
+
+      client = Customerio::APIClient.new(app_key, { region: region })
+    end
+  end
+
+  describe "#send_email" do
+    it "sends a POST request to the /api/send/email path" do
+      req = Customerio::SendEmailRequest.new(
+        identifiers: {
+          id: 'c1',
+        },
+        transactional_message_id: 1,
+      )
+
+      stub_request(:post, api_uri('/v1/send/email'))
+        .with(headers: request_headers, body: req.message)
+        .to_return(status: 200, body: { delivery_id: 1 }.to_json, headers: {})
+
+      client.send_email(req).should eq({ "delivery_id" => 1 })
+    end
+
+    it "handles validation failures (400)" do
+      req = Customerio::SendEmailRequest.new(
+        identifiers: {
+          id: 'c1',
+        },
+        transactional_message_id: 1,
+      )
+
+      err_json = { meta: { error: "example error" } }.to_json
+
+      stub_request(:post, api_uri('/v1/send/email'))
+        .with(headers: request_headers, body: req.message)
+        .to_return(status: 400, body: err_json, headers: {})
+
+      lambda { client.send_email(req) }.should(
+        raise_error(Customerio::InvalidResponse) { |error|
+          error.message.should eq "example error"
+          error.code.should eq "400"
+        }
+      )
+    end
+
+    it "handles other failures (5xx)" do
+      req = Customerio::SendEmailRequest.new(
+        identifiers: {
+          id: 'c1',
+        },
+        transactional_message_id: 1,
+      )
+
+      stub_request(:post, api_uri('/v1/send/email'))
+        .with(headers: request_headers, body: req.message)
+        .to_return(status: 500, body: "Server unavailable", headers: {})
+
+      lambda { client.send_email(req) }.should(
+        raise_error(Customerio::InvalidResponse) { |error|
+          error.message.should eq "Server unavailable"
+          error.code.should eq "500"
+        }
+      )
+    end
+
+    it "allows attaching file content without encoding" do
+      content = 'sample content'
+
+      req = Customerio::SendEmailRequest.new(
+        customer_id: 'c1',
+        transactional_message_id: 1,
+      )
+
+      req.attach('test', content, encode: false)
+      req.message[:attachments]['test'].should eq content
+
+      stub_request(:post, api_uri('/v1/send/email'))
+        .with(headers: request_headers, body: req.message)
+        .to_return(status: 200, body: { delivery_id: 1 }.to_json, headers: {})
+
+      client.send_email(req)
+    end
+
+    it "allows attaching files with encoding (default)" do
+      content = 'sample content'
+
+      req = Customerio::SendEmailRequest.new(
+        customer_id: 'c1',
+        transactional_message_id: 1,
+      )
+
+      req.attach('test', content)
+      req.message[:attachments]['test'].should eq Base64.strict_encode64(content)
+
+      stub_request(:post, api_uri('/v1/send/email'))
+        .with(headers: request_headers, body: req.message)
+        .to_return(status: 200, body: { delivery_id: 1 }.to_json, headers: {})
+
+      client.send_email(req)
+    end
+
+    it "raises error when attaching the same key again" do
+      req = Customerio::SendEmailRequest.new(
+        customer_id: 'c1',
+        transactional_message_id: 1,
+      )
+
+      req.attach('test', 'test-content')
+
+      lambda { req.attach('test', '') }.should raise_error(/attachment test already exists/)
+      req.message[:attachments].should eq({ "test" => Base64.strict_encode64("test-content") })
+    end
+  end
+end

data/spec/base_client_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'multi_json'
+require 'base64'
+
+describe Customerio::BaseClient do
+  let(:url) { "https://test.customer.io" }
+
+  let(:site_id) { "SITE_ID" }
+  let(:api_key) { "API_KEY" }
+  let(:track_client) { Customerio::BaseClient.new({ site_id: site_id, api_key: api_key }, { url: url }) }
+
+  let(:app_key) { "APP_KEY" }
+  let(:api_client) { Customerio::BaseClient.new({ app_key: app_key }, { url: url }) }
+
+  def api_uri(path)
+    "#{url}#{path}"
+  end
+
+  def track_client_request_headers
+    token = Base64.strict_encode64("#{site_id}:#{api_key}")
+    { 'Authorization': "Basic #{token}", 'Content-Type': 'application/json' }
+  end
+
+  def api_client_request_headers
+    { 'Authorization': "Bearer #{app_key}", 'Content-Type': 'application/json' }
+  end
+
+  describe "with a site ID and API key" do
+    it "uses the correct basic auth" do
+      stub_request(:put, api_uri('/some/path')).
+        with(headers: track_client_request_headers).
+        to_return(status: 200, body: "", headers: {})
+
+      track_client.request(:put, '/some/path', "")
+    end
+  end
+
+  describe "with an app key" do
+    it "uses the correct bearer token" do
+      stub_request(:put, api_uri('/some/path')).
+        with(headers: api_client_request_headers).
+        to_return(status: 200, body: "", headers: {})
+
+      api_client.request(:put, '/some/path', "")
+    end
+  end
+
+  describe "#verify_response" do
+    it "throws an error when the response isn't between 200 and 300" do
+      stub_request(:put, api_uri('/some/path')).
+        with(headers: api_client_request_headers).
+        to_return(status: 400, body: "", headers: {})
+
+      lambda { api_client.request_and_verify_response(:put, '/some/path', "") }.should(
+        raise_error(Customerio::InvalidResponse)
+      )
+    end
+
+    it "returns the response when the status is 200" do
+      stub_request(:put, api_uri('/some/path')).
+        with(headers: api_client_request_headers).
+        to_return(status: 200, body: "Test", headers: {})
+
+      api_client.request_and_verify_response(:put, '/some/path', "").body.should eq("Test")
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,39 +1,92 @@
 require 'spec_helper'
 require 'multi_json'
-
+require 'base64'
 
 describe Customerio::Client do
-  let(:client)   { Customerio::Client.new("SITE_ID", "API_KEY", :json => false) }
-  let(:response) { double("Response", :code => 200) }
+  let(:site_id) { "SITE_ID" }
+  let(:api_key) { "API_KEY" }
+
+  let(:client)   { Customerio::Client.new(site_id, api_key) }
+  let(:response) { double("Response", code: 200) }
 
   def api_uri(path)
-    "https://SITE_ID:API_KEY@track.customer.io#{path}"
+    "https://track.customer.io#{path}"
+  end
+
+  def request_headers
+    token = Base64.strict_encode64("#{site_id}:#{api_key}")
+    { 'Authorization': "Basic #{token}", 'Content-Type': 'application/json' }
   end
 
   def json(data)
     MultiJson.dump(data)
   end
 
-  describe "json option" do
-    let(:body) { { :id => 5, :name => "Bob" } }
+  it "the base client is initialised with the correct values when no region is passed in" do
+    site_id = "SITE_ID"
+    api_key = "API_KEY"
+
+    expect(Customerio::BaseClient).to(
+      receive(:new)
+        .with(
+          { site_id: site_id, api_key: api_key },
+          {
+            region: Customerio::Regions::US,
+            url: Customerio::Regions::US.track_url
+          }
+        )
+    )
 
-    it "uses json by default" do
-      client = Customerio::Client.new("SITE_ID", "API_KEY")
+    client = Customerio::Client.new(site_id, api_key)
+  end
 
-      stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => json(body),
-             :headers => {'Content-Type'=>'application/json'}).
-        to_return(:status => 200, :body => "", :headers => {})
+  it "raises an error when an incorrect region is passed in" do
+    expect {
+      Customerio::Client.new("siteid", "apikey", region: :au)
+    }.to raise_error /region must be an instance of Customerio::Regions::Region/
+  end
 
-      client.identify(body)
+  [Customerio::Regions::US, Customerio::Regions::EU].each do |region|
+    it "the base client is initialised with the correct values when the region \"#{region}\" is passed in" do
+      site_id = "SITE_ID"
+      api_key = "API_KEY"
+
+      expect(Customerio::BaseClient).to(
+        receive(:new)
+          .with(
+            { site_id: site_id, api_key: api_key },
+            {
+              region: region,
+              url: region.track_url
+            }
+          )
+      )
+
+      client = Customerio::Client.new(site_id, api_key, { region: region })
     end
+  end
 
-    it "allows disabling json" do
-      client = Customerio::Client.new("SITE_ID", "API_KEY", :json => false)
+  it "uses json by default" do
+    body = { id: 5, name: "Bob" }
+    client = Customerio::Client.new("SITE_ID", "API_KEY")
 
-      stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => { :id => "5", :name => "Bob" }).
-        to_return(:status => 200, :body => "", :headers => {})
+    stub_request(:put, api_uri('/api/v1/customers/5')).
+      with(body: json(body),
+           headers: {'Content-Type'=>'application/json'}).
+      to_return(status: 200, body: "", headers: {})
+
+    client.identify(body)
+  end
+
+  describe "headers" do
+    let(:body) { { id: 1, token: :test } }
+
+    it "sends the basic headers, base64 encoded with the request" do
+      client = Customerio::Client.new("SITE_ID", "API_KEY")
+
+      stub_request(:put, api_uri('/api/v1/customers/1')).
+        with(body: json(body), headers: request_headers).
+        to_return(status: 200, body: "", headers: {})
 
       client.identify(body)
     end
@@ -42,41 +95,54 @@ describe Customerio::Client do
   describe "#identify" do
     it "sends a PUT request to customer.io's customer API" do
       stub_request(:put, api_uri('/api/v1/customers/5')).
-         with(:body => "id=5").
-         to_return(:status => 200, :body => "", :headers => {})
+         with(body: json(id: "5")).
+         to_return(status: 200, body: "", headers: {})
 
-      client.identify(:id => 5)
+      client.identify(id: "5")
+    end
+
+    it "escapes customer IDs" do
+      stub_request(:put, api_uri('/api/v1/customers/5%20')).
+         with(body: json({ id: "5 " })).
+         to_return(status: 200, body: "", headers: {})
+
+      client.identify(id: "5 ")
+
+      stub_request(:put, api_uri('/api/v1/customers/5%2F')).
+         with(body: { id: "5/" }).
+         to_return(status: 200, body: "", headers: {})
+      client.identify(id: "5/")
     end
 
     it "sends a PUT request to customer.io's customer API using json headers" do
-      client = Customerio::Client.new("SITE_ID", "API_KEY", :json => true)
-      body = { :id => 5, :name => "Bob" }
+      client = Customerio::Client.new("SITE_ID", "API_KEY", json: true)
+      body = { id: 5, name: "Bob" }
 
       stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => json(body),
-             :headers => {'Content-Type'=>'application/json'}).
-        to_return(:status => 200, :body => "", :headers => {})
+        with(body: json(body),
+             headers: {'Content-Type'=>'application/json'}).
+        to_return(status: 200, body: "", headers: {})
 
       client.identify(body)
     end
 
     it "raises an error if PUT doesn't return a 2xx response code" do
       stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => "id=5").
-        to_return(:status => 500, :body => "", :headers => {})
+        with(body: json(id: 5)).
+        to_return(status: 500, body: "", headers: {})
 
-      lambda { client.identify(:id => 5) }.should raise_error(Customerio::Client::InvalidResponse)
+      lambda { client.identify(id: 5) }.should raise_error(Customerio::InvalidResponse)
     end
 
     it "includes the HTTP response with raised errors" do
       stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => "id=5").
-        to_return(:status => 500, :body => "whatever", :headers => {})
+        with(body: json(id: 5)).
+        to_return(status: 500, body: "Server unavailable", headers: {})
 
-      lambda { client.identify(:id => 5) }.should raise_error {|error|
-        error.should be_a Customerio::Client::InvalidResponse
-        error.response.code.should eq "500"
-        error.response.body.should eq "whatever"
+      lambda { client.identify(id: 5) }.should raise_error {|error|
+        error.should be_a Customerio::InvalidResponse
+        error.code.should eq "500"
+        error.message.should eq "Server unavailable"
       }
     end
 
@@ -84,31 +150,34 @@ describe Customerio::Client do
       time = Time.now.to_i
 
       stub_request(:put, api_uri('/api/v1/customers/5')).with(
-        :body => {
-          :id => "5",
-          :email => "customer@example.com",
-          :created_at => time.to_s,
-          :first_name => "Bob",
-          :plan => "basic"
-        }).to_return(:status => 200, :body => "", :headers => {})
+        body: {
+          id: 5,
+          email: "customer@example.com",
+          created_at: time,
+          first_name: "Bob",
+          plan: "basic",
+          anonymous_id: "anon-id"
+        }).to_return(status: 200, body: "", headers: {})
 
       client.identify({
-        :id => 5,
-        :email => "customer@example.com",
-        :created_at => time,
-        :first_name => "Bob",
-        :plan => "basic"
+        id: 5,
+        anonymous_id: "anon-id",
+        email: "customer@example.com",
+        created_at: time,
+        first_name: "Bob",
+        plan: "basic"
       })
     end
 
     it "requires an id attribute" do
-      lambda { client.identify(:email => "customer@example.com") }.should raise_error(Customerio::Client::MissingIdAttributeError)
+      lambda { client.identify(email: "customer@example.com") }.should raise_error(Customerio::Client::MissingIdAttributeError)
+      lambda { client.identify(id: "") }.should raise_error(Customerio::Client::MissingIdAttributeError)
     end
 
     it 'should not raise errors when attribute keys are strings' do
       stub_request(:put, api_uri('/api/v1/customers/5')).
-        with(:body => "id=5").
-        to_return(:status => 200, :body => "", :headers => {})
+        with(body: json(id: 5)).
+        to_return(status: 200, body: "", headers: {})
 
       attributes = { "id" => 5 }
 
@@ -119,257 +188,265 @@ describe Customerio::Client do
   describe "#delete" do
     it "sends a DELETE request to the customer.io's event API" do
       stub_request(:delete, api_uri('/api/v1/customers/5')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
       client.delete(5)
     end
+
+    it "throws an error when customer_id is missing" do
+      stub_request(:put, /track.customer.io/)
+        .to_return(status: 200, body: "", headers: {})
+
+      lambda { client.delete(" ") }.should raise_error(Customerio::Client::ParamError, "customer_id must be a non-empty string")
+    end
+
+    it "escapes customer IDs" do
+      stub_request(:delete, api_uri('/api/v1/customers/5%20')).
+         to_return(status: 200, body: "", headers: {})
+
+      client.delete("5 ")
+    end
   end
 
   describe "#suppress" do
     it "sends a POST request to the customer.io's suppress API" do
       stub_request(:post, api_uri('/api/v1/customers/5/suppress')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
       client.suppress(5)
     end
+
+    it "throws an error when customer_id is missing" do
+      stub_request(:put, /track.customer.io/)
+        .to_return(status: 200, body: "", headers: {})
+
+      lambda { client.suppress(" ") }.should raise_error(Customerio::Client::ParamError, "customer_id must be a non-empty string")
+    end
   end
 
   describe "#unsuppress" do
     it "sends a POST request to the customer.io's unsuppress API" do
       stub_request(:post, api_uri('/api/v1/customers/5/unsuppress')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
       client.unsuppress(5)
     end
+
+    it "throws an error when customer_id is missing" do
+      stub_request(:put, /track.customer.io/)
+        .to_return(status: 200, body: "", headers: {})
+
+      lambda { client.suppress(" ") }.should raise_error(Customerio::Client::ParamError, "customer_id must be a non-empty string")
+    end
   end
 
   describe "#track" do
     it "raises an error if POST doesn't return a 2xx response code" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => "name=purchase").
-        to_return(:status => 500, :body => "", :headers => {})
+        with(body: json(name: "purchase", data: {})).
+        to_return(status: 500, body: "", headers: {})
+
+      lambda { client.track(5, "purchase") }.should raise_error(Customerio::InvalidResponse)
+    end
+
+    it "throws an error when customer_id or event_name is missing" do
+      stub_request(:put, /track.customer.io/)
+        .to_return(status: 200, body: "", headers: {})
 
-      lambda { client.track(5, "purchase") }.should raise_error(Customerio::Client::InvalidResponse)
+      lambda { client.track(" ", "test_event") }.should raise_error(Customerio::Client::ParamError, "customer_id must be a non-empty string")
+      lambda { client.track(5, " ") }.should raise_error(Customerio::Client::ParamError, "event_name must be a non-empty string")
     end
 
     it "uses the site_id and api key for basic auth and sends the event name" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => "name=purchase").
-        to_return(:status => 200, :body => "", :headers => {})
+        with(body: json(name: "purchase", data: {})).
+        to_return(status: 200, body: "", headers: {})
 
       client.track(5, "purchase")
     end
 
     it "sends any optional event attributes" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-         with(:body => {
-          :name => "purchase",
-          :data => {
-            :type => "socks",
-            :price => "13.99"
+         with(body: json({
+          name: "purchase",
+          data: {
+            type: "socks",
+            price: "13.99"
           }
-        }).
-        to_return(:status => 200, :body => "", :headers => {})
+        })).
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "purchase", :type => "socks", :price => "13.99")
+      client.track(5, "purchase", type: "socks", price: "13.99")
     end
 
     it "copes with arrays" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-         with(:body => {
-          :name => "event",
-          :data => {
-            :things => ["a", "b", "c"]
+         with(body: {
+          name: "event",
+          data: {
+            things: ["a", "b", "c"]
           }
         }).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "event", :things => ["a", "b", "c"])
+      client.track(5, "event", things: ["a", "b", "c"])
     end
 
     it "copes with hashes" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-         with(:body => {
-          :name => "event",
-          :data => {
-            :stuff => { :a => "b" }
+         with(body: {
+          name: "event",
+          data: {
+            stuff: { a: "b" }
           }
         }).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "event", :stuff => { :a => "b" })
+      client.track(5, "event", stuff: { a: "b" })
     end
 
     it "sends a POST request as json using json headers" do
-      client = Customerio::Client.new("SITE_ID", "API_KEY", :json => true)
-      data = { :type => "socks", :price => "13.99" }
-      body = { :name => "purchase", :data => data }
+      client = Customerio::Client.new("SITE_ID", "API_KEY", json: true)
+      data = { type: "socks", price: "13.99" }
+      body = { name: "purchase", data: data }
 
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => json(body),
-             :headers => {'Content-Type'=>'application/json'}).
-        to_return(:status => 200, :body => "", :headers => {})
+        with(body: json(body),
+             headers: {'Content-Type'=>'application/json'}).
+        to_return(status: 200, body: "", headers: {})
 
       client.track(5, "purchase", data)
     end
 
     it "allows sending of a timestamp" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => {
-          :name => "purchase",
-          :data => {
-            :type => "socks",
-            :price => "13.99",
-            :timestamp => "1561231234"
+        with(body: json({
+          name: "purchase",
+          data: {
+            type: "socks",
+            price: "13.99",
+            timestamp: 1561231234
           },
-          :timestamp => "1561231234"
-        }).
-        to_return(:status => 200, :body => "", :headers => {})
+          timestamp: 1561231234
+        })).
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "purchase", :type => "socks", :price => "13.99", :timestamp => 1561231234)
+      client.track(5, "purchase", type: "socks", price: "13.99", timestamp: 1561231234)
     end
 
     it "doesn't send timestamp if timestamp is in milliseconds" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => {
-          :name => "purchase",
-          :data => {
-            :type => "socks",
-            :price => "13.99",
-            :timestamp => "1561231234000"
+        with(body: json({
+          name: "purchase",
+          data: {
+            type: "socks",
+            price: "13.99",
+            timestamp: 1561231234000
           }
-        }).
-        to_return(:status => 200, :body => "", :headers => {})
+        })).
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "purchase", :type => "socks", :price => "13.99", :timestamp => 1561231234000)
+      client.track(5, "purchase", type: "socks", price: "13.99", timestamp: 1561231234000)
     end
 
     it "doesn't send timestamp if timestamp is a date" do
       date = Time.now
 
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => {
-          :name => "purchase",
-          :data => {
-            :type => "socks",
-            :price => "13.99",
-            :timestamp => Time.now.to_s
+        with(body: {
+          name: "purchase",
+          data: {
+            type: "socks",
+            price: "13.99",
+            timestamp: Time.now.to_s
           }
         }).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "purchase", :type => "socks", :price => "13.99", :timestamp => date)
+      client.track(5, "purchase", type: "socks", price: "13.99", timestamp: date)
     end
 
     it "doesn't send timestamp if timestamp isn't an integer" do
       stub_request(:post, api_uri('/api/v1/customers/5/events')).
-        with(:body => {
-          :name => "purchase",
-          :data => {
-            :type => "socks",
-            :price => "13.99",
-            :timestamp => "Hello world"
+        with(body: json({
+          name: "purchase",
+          data: {
+            type: "socks",
+            price: "13.99",
+            timestamp: "Hello world"
           }
-        }).
+        })).
 
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
-      client.track(5, "purchase", :type => "socks", :price => "13.99", :timestamp => "Hello world")
+      client.track(5, "purchase", type: "socks", price: "13.99", timestamp: "Hello world")
     end
 
     context "tracking an anonymous event" do
+      let(:anon_id) { "anon-id" }
+
       it "sends a POST request to the customer.io's anonymous event API" do
         stub_request(:post, api_uri('/api/v1/events')).
-          with(:body => "name=purchase").
-          to_return(:status => 200, :body => "", :headers => {})
+          with(body: { anonymous_id: anon_id, name: "purchase", data: {} }).
+          to_return(status: 200, body: "", headers: {})
 
-        client.track("purchase")
+        client.track_anonymous(anon_id, "purchase")
       end
 
       it "sends any optional event attributes" do
         stub_request(:post, api_uri('/api/v1/events')).
-          with(:body => {
-            :name => "purchase",
-            :data => {
-              :type => "socks",
-              :price => "13.99"
+          with(body: {
+            anonymous_id: anon_id,
+            name: "purchase",
+            data: {
+              type: "socks",
+              price: "13.99"
             }
           }).
-          to_return(:status => 200, :body => "", :headers => {})
+          to_return(status: 200, body: "", headers: {})
 
-        client.track("purchase", :type => "socks", :price => "13.99")
+        client.track_anonymous(anon_id, "purchase", type: "socks", price: "13.99")
       end
 
       it "allows sending of a timestamp" do
         stub_request(:post, api_uri('/api/v1/events')).
-          with(:body => {
-            :name => "purchase",
-            :data => {
-              :type => "socks",
-              :price => "13.99",
-              :timestamp => "1561231234"
+          with(body: {
+            anonymous_id: anon_id,
+            name: "purchase",
+            data: {
+              type: "socks",
+              price: "13.99",
+              timestamp: 1561231234
             },
-            :timestamp => "1561231234"
+            timestamp: 1561231234
           }).
-          to_return(:status => 200, :body => "", :headers => {})
+          to_return(status: 200, body: "", headers: {})
 
-        client.track("purchase", :type => "socks", :price => "13.99", :timestamp => 1561231234)
+        client.track_anonymous(anon_id, "purchase", type: "socks", price: "13.99", timestamp: 1561231234)
       end
-    end
-  end
 
-  describe "#anonymous_track" do
-    it "raises an error if POST doesn't return a 2xx response code" do
-      stub_request(:post, api_uri('/api/v1/events')).
-        with(:body => "name=purchase").
-        to_return(:status => 500, :body => "", :headers => {})
-
-      lambda { client.anonymous_track("purchase") }.should raise_error(Customerio::Client::InvalidResponse)
-    end
+      it "raises an error if POST doesn't return a 2xx response code" do
+          stub_request(:post, api_uri('/api/v1/events')).
+            with(body: { anonymous_id: anon_id, name: "purchase", data: {} }).
+            to_return(status: 500, body: "", headers: {})
 
-    it "uses the site_id and api key for basic auth and sends the event name" do
-      stub_request(:post, api_uri('/api/v1/events')).
-        with(:body => "name=purchase").
-        to_return(:status => 200, :body => "", :headers => {})
-
-      client.anonymous_track("purchase")
-    end
-
-    it "sends any optional event attributes" do
-      stub_request(:post, api_uri('/api/v1/events')).
-          with(:body => {
-            :name => "purchase",
-            :data => {
-              :type => "socks",
-              :price => "27.99"
-            },
-          }).
-
-        to_return(:status => 200, :body => "", :headers => {})
-
-      client.anonymous_track("purchase", :type => "socks", :price => "27.99")
-    end
+        lambda { client.track_anonymous(anon_id, "purchase") }.should raise_error(Customerio::InvalidResponse)
+      end
 
-    it "allows sending of a timestamp" do
-      stub_request(:post, api_uri('/api/v1/events')).
-          with(:body => {
-            :name => "purchase",
-            :data => {
-              :type => "socks",
-              :price => "27.99",
-              :timestamp => "1561235678"
-            },
-            :timestamp => "1561235678"
-          }).
+      it "throws an error when anonymous_id is missing" do
+          stub_request(:post, api_uri('/api/v1/events')).
+            with(body: { anonymous_id: anon_id, name: "purchase", data: {} }).
+            to_return(status: 500, body: "", headers: {})
 
-        to_return(:status => 200, :body => "", :headers => {})
+        lambda { client.track_anonymous("", "some_event") }.should raise_error(Customerio::Client::ParamError)
+      end
 
-      client.anonymous_track("purchase", :type => "socks", :price => "27.99", :timestamp => 1561235678)
-    end
+      it "throws an error when event_name is missing" do
+          stub_request(:post, api_uri('/api/v1/events')).
+            with(body: { anonymous_id: anon_id, name: "purchase", data: {} }).
+            to_return(status: 500, body: "", headers: {})
 
-    context "too many arguments are passed" do
-      it "throws an error" do
-        lambda { client.anonymous_track("purchase", "text", :type => "socks", :price => "27.99") }.should raise_error(ArgumentError)
+        lambda { client.track_anonymous(anon_id, "") }.should raise_error(Customerio::Client::ParamError)
       end
     end
   end
@@ -377,109 +454,142 @@ describe Customerio::Client do
   describe "#devices" do
     it "allows for the creation of a new device" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
-      client.add_device(5, "androidDeviceID", "ios", {:last_used=>1561235678})
+      client.add_device(5, "androidDeviceID", "ios", {last_used: 1561235678})
       client.add_device(5, "iosDeviceID", "android")
     end
     it "requires a valid customer_id when creating" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.add_device("", "ios", "myDeviceID") }.should raise_error(Customerio::Client::ParamError)
-       lambda { client.add_device(nil, "ios", "myDeviceID", {:last_used=>1561235678}) }.should raise_error(Customerio::Client::ParamError)
+       lambda { client.add_device(nil, "ios", "myDeviceID", {last_used: 1561235678}) }.should raise_error(Customerio::Client::ParamError)
     end
     it "requires a valid token when creating" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.add_device(5, "", "ios") }.should raise_error(Customerio::Client::ParamError)
-       lambda { client.add_device(5, nil, "ios", {:last_used=>1561235678}) }.should raise_error(Customerio::Client::ParamError)
+       lambda { client.add_device(5, nil, "ios", {last_used: 1561235678}) }.should raise_error(Customerio::Client::ParamError)
     end
     it "requires a valid platform when creating" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.add_device(5, "token", "") }.should raise_error(Customerio::Client::ParamError)
-       lambda { client.add_device(5, "toke", nil, {:last_used=>1561235678}) }.should raise_error(Customerio::Client::ParamError)
+       lambda { client.add_device(5, "toke", nil, {last_used: 1561235678}) }.should raise_error(Customerio::Client::ParamError)
     end
     it "accepts a nil data param" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
         client.add_device(5, "ios", "myDeviceID", nil)
     end
     it "fails on invalid data param" do
       stub_request(:put, api_uri('/api/v1/customers/5/devices')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.add_device(5, "ios", "myDeviceID", 1000) }.should raise_error(Customerio::Client::ParamError)
     end
     it "supports deletion of devices by token" do
       stub_request(:delete, api_uri('/api/v1/customers/5/devices/myDeviceID')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
       client.delete_device(5, "myDeviceID")
     end
     it "requires a valid customer_id when deleting" do
       stub_request(:delete, api_uri('/api/v1/customers/5/devices/myDeviceID')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.delete_device("", "myDeviceID") }.should raise_error(Customerio::Client::ParamError)
        lambda { client.delete_device(nil, "myDeviceID") }.should raise_error(Customerio::Client::ParamError)
     end
     it "requires a valid device_id when deleting" do
       stub_request(:delete, api_uri('/api/v1/customers/5/devices/myDeviceID')).
-        to_return(:status => 200, :body => "", :headers => {})
+        to_return(status: 200, body: "", headers: {})
 
        lambda { client.delete_device(5, "") }.should raise_error(Customerio::Client::ParamError)
        lambda { client.delete_device(5, nil) }.should raise_error(Customerio::Client::ParamError)
     end
   end
 
-  describe "#manual_segments" do
+  describe "#track_push_notification_event" do
+    attr_accessor :client, :attributes
 
-    client = Customerio::Client.new("SITE_ID", "API_KEY", :json=>true)
+    before(:each) do
+      @client = Customerio::Client.new("SITE_ID", "API_KEY", :json => true)
+      @attributes = {
+        :delivery_id => 'foo',
+        :device_id => 'bar',
+        :timestamp => Time.now.to_i
+      }
+    end
 
-    it "allows adding customers to a manual segment" do
-      stub_request(:post, api_uri('/api/v1/segments/1/add_customers')).to_return(:status => 200, :body => "", :headers => {})
+    it "sends a POST request to customer.io's /push/events endpoint" do
+      stub_request(:post, api_uri('/push/events')).
+        with(
+          :body => json(attributes.merge({
+              :event => 'opened'
+          })),
+          :headers => {
+            'Content-Type' => 'application/json'
+          }).
+        to_return(:status => 200, :body => "", :headers => {})
 
-      client.add_to_segment(1, ["customer1", "customer2", "customer3"])
+      client.track_push_notification_event('opened', attributes)
     end
-    it "requires a valid segment id when adding customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/add_customers')).to_return(:status => 200, :body => "", :headers => {})
 
-      lambda { client.add_to_segment("not_valid", ["customer1", "customer2", "customer3"]).should raise_error(Customerio::Client::ParamError) }
-    end
-    it "requires a valid customer list when adding customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/add_customers')).to_return(:status => 200, :body => "", :headers => {})
+    it "should raise if event is invalid" do
+      stub_request(:post, api_uri('/push/events')).
+        to_return(:status => 200, :body => "", :headers => {})
 
-      lambda { client.add_to_segment(1, "not_valid").should raise_error(Customerio::Client::ParamError) }
+      expect {
+        client.track_push_notification_event('closed', attributes.merge({ :delivery_id => nil }))
+      }.to raise_error(Customerio::Client::ParamError, 'event_name must be one of opened, converted, or delivered')
     end
-    it "coerces non-string values to strings when adding customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/add_customers')).with(:body=>json({:ids=>["1", "2", "3"]})).to_return(:status => 200, :body => "", :headers => {})
 
-      client.add_to_segment(1, [1, 2, 3])
-    end
-    it "allows removing customers from a manual segment" do
-      stub_request(:post, api_uri('/api/v1/segments/1/remove_customers')).to_return(:status => 200, :body => "", :headers => {})
+    it "should raise if delivery_id is invalid" do
+      stub_request(:post, api_uri('/push/events')).
+        to_return(:status => 200, :body => "", :headers => {})
 
-      client.remove_from_segment(1, ["customer1", "customer2", "customer3"])
-    end
-    it "requires a valid segment id when removing customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/remove_customers')).to_return(:status => 200, :body => "", :headers => {})
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :delivery_id => nil }))
+      }.to raise_error(Customerio::Client::ParamError, 'delivery_id must be a non-empty string')
 
-      lambda { client.remove_from_segment("not_valid", ["customer1", "customer2", "customer3"]).should raise_error(Customerio::Client::ParamError) }
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :delivery_id => '' }))
+      }.to raise_error(Customerio::Client::ParamError, 'delivery_id must be a non-empty string')
     end
-    it "requires a valid customer list when removing customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/remove_customers')).to_return(:status => 200, :body => "", :headers => {})
 
-      lambda { client.remove_from_segment(1, "not_valid").should raise_error(Customerio::Client::ParamError) }
+    it "should raise if device_id is invalid" do
+      stub_request(:post, api_uri('/push/events')).
+        to_return(:status => 200, :body => "", :headers => {})
+
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :device_id => nil }))
+      }.to raise_error(Customerio::Client::ParamError, 'device_id must be a non-empty string')
+
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :device_id => '' }))
+      }.to raise_error(Customerio::Client::ParamError, 'device_id must be a non-empty string')
     end
-    it "coerces non-string values to strings when removing customers" do
-      stub_request(:post, api_uri('/api/v1/segments/1/remove_customers')).with(:body=>json({:ids=>["1", "2", "3"]})).to_return(:status => 200, :body => "", :headers => {})
 
-      client.remove_from_segment(1, [1, 2, 3])
+    it "should raise if timestamp is invalid" do
+      stub_request(:post, api_uri('/push/events')).
+        to_return(:status => 200, :body => "", :headers => {})
+
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :timestamp => nil }))
+      }.to raise_error(Customerio::Client::ParamError, 'timestamp must be a valid timestamp')
+
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :timestamp => 999999999 }))
+      }.to raise_error(Customerio::Client::ParamError, 'timestamp must be a valid timestamp')
+
+      expect {
+        client.track_push_notification_event('opened', attributes.merge({ :timestamp => 100000000000 }))
+      }.to raise_error(Customerio::Client::ParamError, 'timestamp must be a valid timestamp')
     end
   end
 end