mailslurp_client 8.2.1 → 8.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36ce41a5fe3eceb494c8afd8a919e2f5de8fcf5d6df42eea3ee221e4567ab428
-  data.tar.gz: 475f30343f6b85b51a55dec7531bd4bcfe83441f729fbf18d886d36106c2164b
+  metadata.gz: fc32874bf10e7c9c49626c99e69e421891c34df4136a201b8b902485287ec36c
+  data.tar.gz: '086b46c10d486705f9a400be470cba8bc313623d05a666028f735f76f4882234'
 SHA512:
-  metadata.gz: a62a060b64eee4163154b284d0ad61d00dfbdd07f6e07e2f5bca58080334f2e6c615b8280abbe1335289ee716fa73ca59d6ee6e2aab37c39bc84d9cc302181b4
-  data.tar.gz: c5dd378fa61330c8a38df16ec2f773ea42c2f34caff69d9a760e42c57bc69b2f18f699405b7e09f44443a524bb46d97c5fa9c5a1ce5e22b30a9efeccf06c48fe
+  metadata.gz: c16d687eaa9984297f262b08cec0325216bcdf56625677f55675da44b6bda7a9013237632b369fd64bfcd3fde01180b5d40029c9d3b51918578a1ef6d79b37fa
+  data.tar.gz: b25787efbe06f5ca9f2864a8e5ab48c50066ac484cb517b863d407f356a836c37a8a259191f94ca04a5a8250d9b88dd717a0a95ffd0b7485ca104c9e98694217

data/README.md

@@ -13,11 +13,13 @@ MailSlurp is an email API service that lets you create real email addresses in c
 ## Get started
 
 ::: tip
+
 This section describes how to get up and running with the Ruby client.
 
 See the [examples page](https://www.mailslurp.com/examples/) for more examples and use with common frameworks such as Rails and RSpec.
 
 See the method documentation for a [list of all functions](./docs)
+
 :::
 
 ### Create API Key
@@ -39,15 +41,23 @@ gem install mailslurp_client
 Or in your `Gemfile`:
 
 ```ruby
-gem 'mailslurp_client', '~> 7.0', '>= 7.0.8'
+gem 'mailslurp_client', '~> 8.2', '>= 8.2.2'
+```
+
+And then run bundler install:
+
+```bash
+gem install bundler
+bundle install
 ```
 
+
 ### Configure the client
 
 ```ruby
 require 'mailslurp_client'
 
-# configure the mailslurp client with an API Key
+# configure mailslurp client globally with API key (or pass each controller a client instance)
 MailSlurpClient.configure do |config|
     config.api_key['x-api-key'] = "YOUR_API_KEY_HERE"
 end
@@ -80,6 +90,26 @@ it 'can create email addresses' do
 end
 ```
 
+### List inboxes
+
+Inboxes you create can be listed in a paginated way.
+
+```ruby
+it 'can list inboxes' do
+    inbox_controller = MailSlurpClient::InboxControllerApi.new
+    paged_inboxes = inbox_controller.get_all_inboxes({ page: 0, size: 20 })
+
+    # assert on pagination fields
+    expect(paged_inboxes.content).not_to be_empty
+    expect(paged_inboxes.number).to be(0)
+    expect(paged_inboxes.size).to be(20)
+
+    # can access inbox result
+    expect(paged_inboxes.content[0].id).not_to be_empty
+end
+```
+
+
 ### Send emails
 
 You can send HTML emails easily with the inbox controller. First create an inbox then use its ID with the `send_email` method.
@@ -104,6 +134,24 @@ inbox_controller.send_email(inbox.id, {
 })
 ```
 
+You can also use objects for most method options:
+
+```ruby
+# for send options see https://github.com/mailslurp/mailslurp-client-ruby/blob/master/docs/SendEmailOptions.md
+opts = {
+  send_email_options: MailSlurpClient::SendEmailOptions.new(
+    {
+      to: [inbox_2.email_address],
+      subject: 'Test email',
+      from: inbox_1.email_address,
+      body: 'Test email content',
+      is_html: true,
+      attachments: attachment_ids
+    }
+  )
+}
+inbox_controller.send_email(inbox_1.id, opts)
+```
 ### Receive emails
 
 You can use MailSlurp to wait for at least 1 unread email in an inbox and return it.
@@ -111,13 +159,161 @@ If a timeout is exceeded it will throw an error instead:
 
 ```ruby
 waitfor_controller = MailSlurpClient::WaitForControllerApi.new
-email = waitfor_controller.wait_for_latest_email({ inbox_id: inbox.id, unread_only: true })
+email = waitfor_controller.wait_for_latest_email({ inbox_id: inbox.id, unread_only: true, timeout: 30_000 })
 
 # verify email contents
 expect(email.subject).to include("Test")
 expect(email.body).to include("Your email body")
 ```
 
+### Attachments
+
+You can send attachments by first uploading files with the `AttachmentControllerApi` then using the returned attachment IDs in the send email method.
+
+::: tip
+
+MailSlurp endpoints use base64 string encoding for upload and download files. To encode or decode strings in Ruby make sure you use the **strict** variables that avoid added newlines.
+
+:::
+
+#### Upload and send
+```ruby
+# upload a file to mailslurp to use as attachment
+# @return [Array<String>]
+def upload_file
+# read a file to upload
+data = File.open(PATH_TO_ATTACHMENT).read
+
+# encode the data as base64 string (must be strict to avoid ruby adding new line characters)
+encoded = Base64.strict_encode64(data)
+
+attachment_controller = MailSlurpClient::AttachmentControllerApi.new
+upload_options = MailSlurpClient::UploadAttachmentOptions.new(
+  {
+    base64_contents: encoded,
+    content_type: 'text/plain',
+    filename: 'attachment.txt'
+  }
+)
+
+# return list of attachment ids
+attachment_controller.upload_attachment(upload_options)
+end
+```
+
+To send attachments
+
+```ruby
+attachment_ids = upload_file
+
+opts = {
+  send_email_options: MailSlurpClient::SendEmailOptions.new(
+    {
+      to: [inbox_2.email_address],
+      subject: 'Test email',
+      from: inbox_1.email_address,
+      body: 'Test email content',
+      is_html: true,
+      attachments: attachment_ids
+    }
+  )
+}
+inbox_controller.send_email(inbox_1.id, opts)
+```
+
+#### Download received attachments
+```ruby
+ # wait for the email to arrive (or fetch directly using email controller if you know it is there)
+wait_opts = {
+  inbox_id: inbox_2.id,
+  timeout: 30_000,
+  unread_only: true
+}
+email = wait_controller.wait_for_latest_email(wait_opts)
+
+# find the attachments on the email object
+expect(email.attachments.size).to be(1)
+
+# download the attachment
+email_controller = MailSlurpClient::EmailControllerApi.new
+downloaded_attachment = email_controller.download_attachment_base64(email.attachments[0], email.id)
+
+# extract attachment content
+expect(downloaded_attachment.content_type).to eq("text/plain")
+expect(downloaded_attachment.size_bytes).to be_truthy
+expect(downloaded_attachment.base64_file_contents).to be_truthy
+```
+
+## Examples
+
+### Send email between two inboxes
+
+It is common to use MailSlurp in test environments. Here is an example RSpec test:
+
+```ruby
+
+require 'mailslurp_client'
+
+# read mailslurp api key from environment variables
+API_KEY = ENV['API_KEY']
+
+describe 'use MailSlurp ruby sdk to create email addresses then send and receive email' do
+  before(:all) do
+    expect(API_KEY).to be_truthy
+
+    # configure mailslurp with API key
+    MailSlurpClient.configure do |config|
+      config.api_key['x-api-key'] = API_KEY
+    end
+  end
+
+  it 'can an inbox with an email address' do
+    # create a new email address
+    inbox_controller = MailSlurpClient::InboxControllerApi.new
+    inbox = inbox_controller.create_inbox
+
+    # has a mailslurp email address
+    expect(inbox.id).to be_truthy
+    expect(inbox.email_address).to include('@mailslurp.com')
+  end
+
+  it 'can send and receive emails' do
+    inbox_controller = MailSlurpClient::InboxControllerApi.new
+    wait_controller  = MailSlurpClient::WaitForControllerApi.new
+
+    # create two inboxes
+    inbox_1 = inbox_controller.create_inbox
+    inbox_2 = inbox_controller.create_inbox
+
+    # send email from inbox 1 to inbox 2 (you can send emails to any address)
+    # for send options see https://github.com/mailslurp/mailslurp-client-ruby/blob/master/docs/SendEmailOptions.md
+    opts = {
+      send_email_options: MailSlurpClient::SendEmailOptions.new(
+        {
+          to: [inbox_2.email_address],
+          subject: 'Test email',
+          from: inbox_1.email_address,
+          body: 'Test email content',
+          is_html: true
+        }
+      )
+    }
+    inbox_controller.send_email(inbox_1.id, opts)
+
+    expect(inbox_2.id).to be_truthy
+
+    # now wait for the email to arrive
+    wait_opts = {
+      inbox_id: inbox_2.id,
+      timeout: 30_000,
+      unread_only: true
+    }
+    email = wait_controller.wait_for_latest_email(wait_opts)
+    expect(email.body).to include('Test email content')
+  end
+end
+```
+
 ## SDK Documentation
 
 See the [examples page](https://www.mailslurp.com/examples/) or the full [Method Documentation](./docs) on Github.

data/lib/mailslurp_client/api/attachment_controller_api.rb

@@ -19,7 +19,7 @@ module MailSlurpClient
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
-    # Upload an attachment for sending
+    # Upload an attachment for sending using base64 file encoding
     # When sending emails with attachments first upload each attachment with this endpoint. Record the returned attachment IDs. Then use these attachment IDs in the SendEmailOptions when sending an email. This means that attachments can easily be reused.
     # @param upload_options [UploadAttachmentOptions] uploadOptions
     # @param [Hash] opts the optional parameters
@@ -29,7 +29,7 @@ module MailSlurpClient
       data
     end
 
-    # Upload an attachment for sending
+    # Upload an attachment for sending using base64 file encoding
     # When sending emails with attachments first upload each attachment with this endpoint. Record the returned attachment IDs. Then use these attachment IDs in the SendEmailOptions when sending an email. This means that attachments can easily be reused.
     # @param upload_options [UploadAttachmentOptions] uploadOptions
     # @param [Hash] opts the optional parameters
@@ -83,6 +83,66 @@ module MailSlurpClient
       return data, status_code, headers
     end
 
+    # Upload an attachment for sending using file byte stream input octet stream
+    # When sending emails with attachments first upload each attachment with this endpoint. Record the returned attachment IDs. Then use these attachment IDs in the SendEmailOptions when sending an email. This means that attachments can easily be reused.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :filename Optional filename to save upload with
+    # @return [Array<String>]
+    def upload_attachment_bytes(opts = {})
+      data, _status_code, _headers = upload_attachment_bytes_with_http_info(opts)
+      data
+    end
+
+    # Upload an attachment for sending using file byte stream input octet stream
+    # When sending emails with attachments first upload each attachment with this endpoint. Record the returned attachment IDs. Then use these attachment IDs in the SendEmailOptions when sending an email. This means that attachments can easily be reused.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :filename Optional filename to save upload with
+    # @return [Array<(Array<String>, Integer, Hash)>] Array<String> data, response status code and response headers
+    def upload_attachment_bytes_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AttachmentControllerApi.upload_attachment_bytes ...'
+      end
+      # resource path
+      local_var_path = '/attachments/bytes'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/octet-stream'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(opts[:'filename']) 
+
+      # return_type
+      return_type = opts[:return_type] || 'Array<String>' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['API_KEY']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AttachmentControllerApi#upload_attachment_bytes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Upload an attachment for sending using Multipart Form
     # When sending emails with attachments first upload each attachment with this endpoint. Record the returned attachment IDs. Then use these attachment IDs in the SendEmailOptions when sending an email. This means that attachments can easily be reused.
     # @param file [File] file

data/lib/mailslurp_client/models/upload_attachment_options.rb

@@ -15,7 +15,7 @@ require 'date'
 module MailSlurpClient
   # Options for uploading files for attachments. When sending emails with the API that require attachments first upload each attachment. Then use the returned attachment ID in your `SendEmailOptions` when sending an email. This way you can use attachments multiple times once they have been uploaded.
   class UploadAttachmentOptions
-    # Base64 encoded string of file contents
+    # Base64 encoded string of file contents. Typically this means reading the bytes or string content of a file and then converting that to a base64 encoded string.
     attr_accessor :base64_contents
 
     # Optional contentType for file. For instance `application/pdf`

data/lib/mailslurp_client/version.rb

@@ -11,5 +11,5 @@ OpenAPI Generator version: 4.3.1
 =end
 
 module MailSlurpClient
-  VERSION = '8.2.1'
+  VERSION = '8.2.7'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mailslurp_client
 version: !ruby/object:Gem::Version
-  version: 8.2.1
+  version: 8.2.7
 platform: ruby
 authors:
 - mailslurp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-19 00:00:00.000000000 Z
+date: 2020-11-20 00:00:00.000000000 Z
 dependencies: []
 description: Create emails addresses in Ruby then send and receive real emails and
   attachments. See https://www.mailslurp.com/docs/ruby/ for full Ruby documentation.