minitel 0.6.0 → 1.0.0

data/spec/minitel/client_spec.rb

@@ -1,120 +1,252 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe Minitel::Client, '#initialize' do
-  before do
-    url = "https://u:p@foo.com"
-    client = Minitel::Client.new(url)
-    @data = client.connection.data
-  end
+require "spec_helper"
 
-  it 'uses the given url and credentials' do
-    expect(@data[:host]).to     eq('foo.com')
-    expect(@data[:user]).to     eq('u')
-    expect(@data[:password]).to eq('p')
-  end
+RSpec.describe Minitel::Client do
+  describe "#initialize" do
+    let(:client) { described_class.new("https://EXAMPLE-KEY0-0000-0000-000000000000:EXAMPLE-SEC0-0000-0000-000000000000@telex.example.com") }
 
-  it 'includes the minitel and excon versions in the user agent' do
-    user_agent = @data[:headers]['User-Agent']
-    expect(user_agent).to match('minitel')
-    expect(user_agent).to match(Minitel::VERSION)
-    expect(user_agent).to match('excon')
-    expect(user_agent).to match(Excon::VERSION)
-  end
+    it "uses the given url and credentials" do
+      expect(client.uri.host).to eq("telex.example.com")
+      expect(client.user).to eq("EXAMPLE-KEY0-0000-0000-000000000000")
+      expect(client.password).to eq("EXAMPLE-SEC0-0000-0000-000000000000")
+    end
 
-  it 'requires an https url' do
-    expect{ Minitel::Client.new('http://user:pass@what.com')  }.to     raise_error(ArgumentError)
-    expect{ Minitel::Client.new('https://user:pass@what.com') }.to_not raise_error
+    it "requires an https url" do
+      expect { described_class.new("http://user:pass@what.com") }.to raise_error(ArgumentError)
+      expect { described_class.new("https://user:pass@what.com") }.not_to raise_error
+    end
   end
-end
 
-describe Minitel::Client, '#notify_app' do
-  describe 'action' do
-    let(:defaults) { {title: 'a title', body: 'a body', app_uuid: SecureRandom.uuid} }
-    let(:client)   { Minitel::Client.new('https://telex.com') }
+  describe "#notify_app" do
+    let(:defaults) { { title: "a title", body: "a body", app_uuid: SecureRandom.uuid } }
+    let(:client) { described_class.new("https://EXAMPLE-KEY0-0000-0000-000000000000:EXAMPLE-SEC0-0000-0000-000000000000@telex.example.com") }
+    let!(:stub) do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 201, body: JSON.generate(success: true))
+    end
 
-    before do
-      @stub = stub_request(:post, 'https://telex.com/producer/messages').
-        to_return(status: 201, body: MultiJson.encode(success: true))
+    it "posts a proper json body to the producer messages endpoint" do
+      client.notify_app(defaults)
+      body = JSON.generate(
+        title: "a title",
+        body: "a body",
+        target: { type: "app", id: defaults[:app_uuid] },
+      )
+      expect(stub.with(body: body)).to have_been_requested
     end
 
-    it 'posts a proper json body to the producer messages endpoint' do
+    it "sends basic auth credentials" do
       client.notify_app(defaults)
-      body = MultiJson.encode(
-        title: 'a title',
-        body: 'a body',
-        target: {type: 'app', id: defaults[:app_uuid]})
-      expect(@stub.with(body: body)).to have_been_requested
+      expect(stub.with(basic_auth: ["EXAMPLE-KEY0-0000-0000-000000000000", "EXAMPLE-SEC0-0000-0000-000000000000"])).to have_been_requested
     end
 
-    it 'supports actions' do
-      action = { label: 'omg', url: 'https://foo' }
+    it "sends correct content-type and user-agent headers" do
+      client.notify_app(defaults)
+      expect(stub.with(headers: {
+        "Content-Type" => "application/json",
+        "User-Agent" => "minitel/#{Minitel::VERSION}",
+      })).to have_been_requested
+    end
+
+    it "supports actions" do
+      action = { label: "omg", url: "https://foo" }
       client.notify_app(defaults.merge(action: action))
-      post_with_action = @stub.with do |req|
-        body = MultiJson.decode(req.body, symbolize_keys: true)
+      post_with_action = stub.with do |req|
+        body = JSON.parse(req.body, symbolize_names: true)
         body[:action] == action
       end
       expect(post_with_action).to have_been_requested
     end
 
-    it 'returns a parsed json response' do
+    it "returns a parsed json response" do
       result = client.notify_app(defaults)
-      expect(result['success']).to eq(true)
+      expect(result["success"]).to be(true)
     end
-  end
-end
 
+    it "raises ClientError on a client error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 422, body: JSON.generate(error: "invalid"))
+      expect { client.notify_app(defaults) }.to raise_error(Minitel::HTTP::ClientError)
+    end
 
-describe Minitel::Client, '#notify_user' do
-  let(:defaults) { {title: 'a title', body: 'a body', user_uuid: SecureRandom.uuid} }
-  let(:client)   { Minitel::Client.new('https://telex.com') }
+    it "raises NotFound on a 404 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 404, body: "Not Found")
+      expect { client.notify_app(defaults) }.to raise_error(Minitel::HTTP::NotFound)
+    end
 
-  before do
-    @stub = stub_request(:post, 'https://telex.com/producer/messages').
-      to_return(status: 201, body: MultiJson.encode(success: true))
-  end
+    it "sets cause to the Minitel error when a caller rescues and re-raises" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 404, body: "Not Found")
+      wrapper_error = Class.new(StandardError)
+      begin
+        begin
+          client.notify_app(defaults)
+        rescue => e
+          raise wrapper_error, e.message
+        end
+      rescue wrapper_error => e
+        expect(e.cause).to be_instance_of(Minitel::HTTP::NotFound)
+      end
+    end
 
-  it 'posts a proper json body to the producer messages endpoint' do
-    client.notify_user(defaults)
-    body = MultiJson.encode(
-      title: 'a title',
-      body: 'a body',
-      target: {type: 'user', id: defaults[:user_uuid]})
-    expect(@stub.with(body: body)).to have_been_requested
-  end
+    it "raises TooManyRequests on a 429 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 429, body: "Rate Limited")
+      expect { client.notify_app(defaults) }.to raise_error(Minitel::HTTP::TooManyRequests)
+    end
 
-  it 'supports actions' do
-    action = { label: 'omg', url: 'https://foo' }
-    client.notify_user(defaults.merge(action: action))
-    post_with_action = @stub.with do |req|
-      body = MultiJson.decode(req.body, symbolize_keys: true)
-      body[:action] == action
+    it "raises ServerError on a server error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 500, body: "Internal Server Error")
+      expect { client.notify_app(defaults) }.to raise_error(Minitel::HTTP::ServerError)
     end
-    expect(post_with_action).to have_been_requested
-  end
 
-  it 'returns a parsed json response' do
-    result = client.notify_user(defaults)
-    expect(result['success']).to eq(true)
+    it "raises on an unexpected success status code" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 200, body: JSON.generate(success: true))
+      expect { client.notify_app(defaults) }.to raise_error(Minitel::HTTP::Error)
+    end
   end
-end
 
-describe Minitel::Client, '#add_followup' do
-  let(:defaults) { {body: 'a body', message_uuid: SecureRandom.uuid} }
-  let(:client)   { Minitel::Client.new('https://telex.com') }
+  describe "#notify_user" do
+    let(:defaults) { { title: "a title", body: "a body", user_uuid: SecureRandom.uuid } }
+    let(:client) { described_class.new("https://EXAMPLE-KEY0-0000-0000-000000000000:EXAMPLE-SEC0-0000-0000-000000000000@telex.example.com") }
+    let!(:stub) do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 201, body: JSON.generate(success: true))
+    end
 
-  before do
-    @stub = stub_request(:post, "https://telex.com/producer/messages/#{defaults[:message_uuid]}/followups").
-      to_return(status: 201, body: MultiJson.encode(success: true))
-  end
+    it "posts a proper json body to the producer messages endpoint" do
+      client.notify_user(defaults)
+      body = JSON.generate(
+        title: "a title",
+        body: "a body",
+        target: { type: "user", id: defaults[:user_uuid] },
+      )
+      expect(stub.with(body: body)).to have_been_requested
+    end
+
+    it "sends basic auth credentials" do
+      client.notify_user(defaults)
+      expect(stub.with(basic_auth: ["EXAMPLE-KEY0-0000-0000-000000000000", "EXAMPLE-SEC0-0000-0000-000000000000"])).to have_been_requested
+    end
+
+    it "sends correct content-type and user-agent headers" do
+      client.notify_user(defaults)
+      expect(stub.with(headers: {
+        "Content-Type" => "application/json",
+        "User-Agent" => "minitel/#{Minitel::VERSION}",
+      })).to have_been_requested
+    end
 
-  it 'posts a proper json body to the producer messages endpoint' do
-    client.add_followup(defaults)
-    body = MultiJson.encode(body: 'a body')
-    expect(@stub.with(body: body)).to have_been_requested
+    it "supports actions" do
+      action = { label: "omg", url: "https://foo" }
+      client.notify_user(defaults.merge(action: action))
+      post_with_action = stub.with do |req|
+        body = JSON.parse(req.body, symbolize_names: true)
+        body[:action] == action
+      end
+      expect(post_with_action).to have_been_requested
+    end
+
+    it "returns a parsed json response" do
+      result = client.notify_user(defaults)
+      expect(result["success"]).to be(true)
+    end
+
+    it "raises ClientError on a client error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 422, body: JSON.generate(error: "invalid"))
+      expect { client.notify_user(defaults) }.to raise_error(Minitel::HTTP::ClientError)
+    end
+
+    it "raises NotFound on a 404 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 404, body: "Not Found")
+      expect { client.notify_user(defaults) }.to raise_error(Minitel::HTTP::NotFound)
+    end
+
+    it "raises TooManyRequests on a 429 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 429, body: "Rate Limited")
+      expect { client.notify_user(defaults) }.to raise_error(Minitel::HTTP::TooManyRequests)
+    end
+
+    it "raises ServerError on a server error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 500, body: "Internal Server Error")
+      expect { client.notify_user(defaults) }.to raise_error(Minitel::HTTP::ServerError)
+    end
+
+    it "raises on an unexpected success status code" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages")
+        .to_return(status: 200, body: JSON.generate(success: true))
+      expect { client.notify_user(defaults) }.to raise_error(Minitel::HTTP::Error)
+    end
   end
 
-  it 'returns a parsed json response' do
-    result = client.add_followup(defaults)
-    expect(result['success']).to eq(true)
+  describe "#add_followup" do
+    let(:defaults) { { body: "a body", message_uuid: SecureRandom.uuid } }
+    let(:client) { described_class.new("https://EXAMPLE-KEY0-0000-0000-000000000000:EXAMPLE-SEC0-0000-0000-000000000000@telex.example.com") }
+    let!(:stub) do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 201, body: JSON.generate(success: true))
+    end
+
+    it "posts a proper json body to the producer messages endpoint" do
+      client.add_followup(defaults)
+      body = JSON.generate(body: "a body")
+      expect(stub.with(body: body)).to have_been_requested
+    end
+
+    it "sends basic auth credentials" do
+      client.add_followup(defaults)
+      expect(stub.with(basic_auth: ["EXAMPLE-KEY0-0000-0000-000000000000", "EXAMPLE-SEC0-0000-0000-000000000000"])).to have_been_requested
+    end
+
+    it "sends correct content-type and user-agent headers" do
+      client.add_followup(defaults)
+      expect(stub.with(headers: {
+        "Content-Type" => "application/json",
+        "User-Agent" => "minitel/#{Minitel::VERSION}",
+      })).to have_been_requested
+    end
+
+    it "returns a parsed json response" do
+      result = client.add_followup(defaults)
+      expect(result["success"]).to be(true)
+    end
+
+    it "raises ClientError on a client error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 422, body: JSON.generate(error: "invalid"))
+      expect { client.add_followup(defaults) }.to raise_error(Minitel::HTTP::ClientError)
+    end
+
+    it "raises NotFound on a 404 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 404, body: "Not Found")
+      expect { client.add_followup(defaults) }.to raise_error(Minitel::HTTP::NotFound)
+    end
+
+    it "raises TooManyRequests on a 429 response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 429, body: "Rate Limited")
+      expect { client.add_followup(defaults) }.to raise_error(Minitel::HTTP::TooManyRequests)
+    end
+
+    it "raises ServerError on a server error response" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 500, body: "Internal Server Error")
+      expect { client.add_followup(defaults) }.to raise_error(Minitel::HTTP::ServerError)
+    end
+
+    it "raises on an unexpected success status code" do
+      WebMock.stub_request(:post, "https://telex.example.com/producer/messages/#{defaults[:message_uuid]}/followups")
+        .to_return(status: 200, body: JSON.generate(success: true))
+      expect { client.add_followup(defaults) }.to raise_error(Minitel::HTTP::Error)
+    end
   end
 end

data/spec/minitel/strict_args_spec.rb

@@ -1,41 +1,40 @@
-require 'spec_helper'
-
-describe Minitel::StrictArgs, '.enforce' do
-  describe 'arguments' do
-    before do
-      @hash = {one: 1, two: 2, uuid: SecureRandom.uuid}
-      @required = [:one, :uuid]
-      @optional = [:two]
-    end
+# frozen_string_literal: true
+
+require "spec_helper"
 
-    it 'works when all listed args are present' do
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid)  }.to_not raise_error
+RSpec.describe Minitel::StrictArgs do
+  describe ".enforce" do
+    let(:input) { { one: 1, two: 2, uuid: SecureRandom.uuid } }
+    let(:required_keys) { [:one, :uuid] }
+    let(:optional_keys) { [:two] }
+
+    it "works when all listed args are present" do
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.not_to raise_error
     end
 
-    it 'works when optional args are omitted' do
-      @hash.delete(:two)
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid)  }.to_not raise_error
+    it "works when optional args are omitted" do
+      input.delete(:two)
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.not_to raise_error
     end
 
     it "fails when a key is missing from the arg hash" do
-      @hash.delete(:one)
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid) }.to raise_error(ArgumentError)
+      input.delete(:one)
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.to raise_error(ArgumentError)
     end
 
     it "fails when a key is nil" do
-      @hash[:one] = nil
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid) }.to raise_error(ArgumentError)
+      input[:one] = nil
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.to raise_error(ArgumentError)
     end
 
-    it 'fails if the uuid column uuid is not a uuid' do
-      @hash[:uuid] = "not a uuid"
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid) }.to raise_error(ArgumentError)
+    it "fails if the uuid column uuid is not a uuid" do
+      input[:uuid] = "not a uuid"
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.to raise_error(ArgumentError)
     end
 
-    it 'fails if there is an extra key' do
-      @hash.merge!( {foo: 3} )
-      expect { Minitel::StrictArgs.enforce(@hash, @required, @optional, :uuid) }.to raise_error(ArgumentError)
+    it "fails if there is an extra key" do
+      input[:foo] = 3
+      expect { described_class.enforce(input, required_keys, optional_keys, :uuid) }.to raise_error(ArgumentError)
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -1,7 +1,11 @@
-require 'rubygems'
-require 'rspec'
-require 'webmock/rspec'
-require 'minitel'
+# frozen_string_literal: true
+
+require "rubygems"
+require "rspec"
+require "webmock/rspec"
+require "minitel"
 
 RSpec.configure do |config|
+  config.order = :random
+  config.disable_monkey_patching!
 end

metadata

@@ -1,99 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: minitel
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Will Leinweber
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: excon
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.20'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: guard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.3'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
+        version: '0'
 description: "\U0001D54B\U0001D53C\U0001D543\U0001D53C\U0001D54F client"
 email:
 - will@bitfission.com
@@ -104,15 +34,19 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_standardrb.yml"
+- ".rubocop_standardrb_overrides.yml"
+- CHANGELOG.md
 - CODEOWNERS
 - Gemfile
 - Guardfile
 - LICENSE
+- README.md
 - Rakefile
-- Readme.md
-- changelog.txt
 - lib/minitel.rb
 - lib/minitel/client.rb
+- lib/minitel/errors.rb
 - lib/minitel/strict_args.rb
 - lib/minitel/version.rb
 - minitel.gemspec
@@ -131,18 +65,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: "\U0001D54B\U0001D53C\U0001D543\U0001D53C\U0001D54F client: see https://github.com/heroku/telex"
-test_files:
-- spec/minitel/client_spec.rb
-- spec/minitel/strict_args_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/changelog.txt

@@ -1,38 +0,0 @@
-0.6.0 2025-05-01
-================
-
-Allow use of newer versions of excon
-
-0.5.0 2021-08-06
-================
-
-also send JSON content type
-move to GitHub Actions
-
-0.4.0 XXXX-XX-XX
-================
-
-0.3.0 2014-10-21
-================
-
-Add Client#add_followup for adding followup to a previous notification
-
-0.2.0 2014-10-10
-================
-
-Add Client#notify_user for sending notifications to a single user
-
-0.1.1 2014-10-08
-================
-
-Add a User-Agent header
-
-0.1.0 2014-10-08
-================
-
-Bump minimum version of Excon to redact passwords on errors
-
-0.0.1 2014-10-04
-================
-
-initial release