Fix tests

Author: ikhimenko

.github/workflows/publish-to-rubygems.yml

@@ -9,23 +9,23 @@ on:
     branches: [main, master]
 
 jobs:
-#  test:
-#    name: Test
-#    runs-on: ubuntu-latest
-#    steps:
-#      - uses: actions/checkout@v4
-#
-#      - uses: ruby/setup-ruby@v1
-#        with:
-#          ruby-version: "2.6"
-#          bundler-cache: true
-#
-#      - name: Run tests
-#        run: bundle exec rspec spec --format progress
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "2.6"
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rspec spec --format progress
 
   publish:
     name: Build & Publish gem
-#    needs: test
+    needs: test
     if: github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
     permissions:
@@ -47,4 +47,4 @@ jobs:
         uses: rubygems/configure-rubygems-credentials@v1.0.0
 
       - name: Publish gem
-        run: gem push lara-sdk-*.gem
+        run: gem push lara-sdk-*.gem

spec/fixtures/audio.json

@@ -0,0 +1,15 @@
+{
+  "content": {
+    "id": "aud_4Ef5Gh6Ij7Kl8Mn9Op0Qr",
+    "status": "translated",
+    "target": "it",
+    "filename": "test.mp3",
+    "source": "en-US",
+    "created_at": "2024-01-15T10:00:00Z",
+    "updated_at": "2024-01-15T10:05:00Z",
+    "options": null,
+    "translated_seconds": 120.5,
+    "total_seconds": 120.5,
+    "error_reason": null
+  }
+}

spec/lara/audio_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "spec_helper"
+
+RSpec.describe Lara::AudioTranslator do
+  let(:base_url) { Lara::Client::DEFAULT_BASE_URL }
+  let(:credentials) { Lara::Credentials.new("test-id", "test-secret") }
+  let(:client) { Lara::Client.new(credentials, base_url: base_url) }
+  let(:s3_double) do
+    double("S3Client").tap do |s3|
+      allow(s3).to receive(:upload).and_return(nil)
+      allow(s3).to receive(:download).and_return("translated audio bytes")
+    end
+  end
+  let(:audio) { described_class.new(client, s3_double) }
+
+  let(:audio_id) { "aud_4Ef5Gh6Ij7Kl8Mn9Op0Qr" }
+
+  def audio_content
+    api_content_fixture("audio")
+  end
+
+  describe "#upload" do
+    it "fetches upload-url, uploads to S3, posts audio and returns Audio" do
+      upload_url_response = { "url" => "https://s3-fake.example.com/upload", "fields" => { "key" => "s3key-1" } }
+      stub_request(:get, "#{base_url}/v2/audio/upload-url")
+        .with(query: hash_including({}))
+        .to_return(
+          status: 200,
+          body: { "content" => upload_url_response }.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      stub_request(:post, "#{base_url}/v2/audio/translate").to_return(
+        status: 200,
+        body: { "content" => audio_content }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      Tempfile.create(["audio", ".mp3"]) do |f|
+        f.write("audio content")
+        f.rewind
+        result = audio.upload(file_path: f.path, filename: "test.mp3", target: "it", source: "en")
+        expect(result).to be_a(Lara::Models::Audio)
+        expect(result.id).to eq(audio_id)
+        expect(result.status).to eq("translated")
+        expect(s3_double).to have_received(:upload).with(url: upload_url_response["url"],
+                                                         fields: upload_url_response["fields"], io: f.path)
+      end
+    end
+
+    it "sends X-No-Trace when no_trace true" do
+      upload_url_response = { "url" => "https://s3-fake.example.com/upload", "fields" => { "key" => "k1" } }
+      stub_request(:get, "#{base_url}/v2/audio/upload-url")
+        .with(query: hash_including({}))
+        .to_return(
+          status: 200,
+          body: { "content" => upload_url_response }.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      stub_request(:post, "#{base_url}/v2/audio/translate").to_return(
+        status: 200,
+        body: { "content" => audio_content }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      Tempfile.create(["audio", ".mp3"]) do |f|
+        f.rewind
+        audio.upload(file_path: f.path, filename: "x.mp3", target: "it", no_trace: true)
+        expect(WebMock).to have_requested(:post,
+                                          "#{base_url}/v2/audio/translate").with(headers: { "X-No-Trace" => "true" })
+      end
+    end
+  end
+
+  describe "#status" do
+    it "returns Audio" do
+      stub_request(:get, "#{base_url}/v2/audio/#{audio_id}").to_return(
+        status: 200,
+        body: { "content" => audio_content }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      result = audio.status(audio_id)
+      expect(result).to be_a(Lara::Models::Audio)
+      expect(result.id).to eq(audio_id)
+    end
+  end
+
+  describe "#download" do
+    it "fetches download-url and returns S3 download body" do
+      download_url = "https://s3-fake.example.com/download/#{audio_id}"
+      stub_request(:get, "#{base_url}/v2/audio/#{audio_id}/download-url").to_return(
+        status: 200,
+        body: { "content" => { "url" => download_url } }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      result = audio.download(audio_id)
+      expect(result).to eq("translated audio bytes")
+      expect(s3_double).to have_received(:download).with(url: download_url)
+    end
+  end
+
+  describe "#translate" do
+    it "uploads, polls until translated, downloads and returns bytes" do
+      upload_url_response = { "url" => "https://s3-fake.example.com/upload", "fields" => { "key" => "k1" } }
+      download_url = "https://s3-fake.example.com/download/#{audio_id}"
+      stub_request(:get, "#{base_url}/v2/audio/upload-url")
+        .with(query: hash_including({}))
+        .to_return(
+          status: 200,
+          body: { "content" => upload_url_response }.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      stub_request(:post, "#{base_url}/v2/audio/translate").to_return(
+        status: 200,
+        body: { "content" => audio_content.merge("status" => "translated") }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      stub_request(:get, "#{base_url}/v2/audio/#{audio_id}").to_return(
+        status: 200,
+        body: { "content" => audio_content.merge("status" => "translated") }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      stub_request(:get, "#{base_url}/v2/audio/#{audio_id}/download-url").to_return(
+        status: 200,
+        body: { "content" => { "url" => download_url } }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      audio.instance_variable_set(:@polling_interval, 0)
+      Tempfile.create(["audio", ".mp3"]) do |f|
+        f.rewind
+        result = audio.translate(file_path: f.path, filename: "test.mp3", target: "it")
+        expect(result).to eq("translated audio bytes")
+      end
+    end
+
+    it "raises LaraApiError when status becomes error" do
+      upload_url_response = { "url" => "https://s3-fake.example.com/upload", "fields" => { "key" => "k1" } }
+      stub_request(:get, "#{base_url}/v2/audio/upload-url")
+        .with(query: hash_including({}))
+        .to_return(
+          status: 200,
+          body: { "content" => upload_url_response }.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      stub_request(:post, "#{base_url}/v2/audio/translate").to_return(
+        status: 200,
+        body: { "content" => audio_content.merge("status" => "initialized") }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      stub_request(:get, "#{base_url}/v2/audio/#{audio_id}").to_return(
+        status: 200,
+        body: { "content" => audio_content.merge("status" => "error",
+                                                 "error_reason" => "Audio processing failed") }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      audio.instance_variable_set(:@polling_interval, 0)
+      Tempfile.create(["audio", ".mp3"]) do |f|
+        f.rewind
+        expect { audio.translate(file_path: f.path, filename: "test.mp3", target: "it") }
+          .to raise_error(Lara::LaraApiError, /Audio processing failed/)
+      end
+    end
+  end
+end

spec/lara/client_spec.rb

@@ -7,14 +7,14 @@
   let(:base_url) { "https://api.laratranslate.com" }
   let(:client) { described_class.new(credentials, base_url: base_url) }
 
-  def stub_api(method_override, path, response_body:, content_type: "application/json",
+  def stub_api(method, path, response_body:, content_type: "application/json",
                status: 200)
     url = if path.start_with?("http")
             path
           else
             "#{base_url}#{path.start_with?('/') ? path : "/#{path}"}"
           end
-    stub_request(:post, url).to_return(
+    stub_request(method.downcase.to_sym, url).to_return(
       status: status,
       body: response_body.is_a?(Hash) ? response_body.to_json : response_body,
       headers: { "Content-Type" => content_type }
@@ -42,7 +42,7 @@ def stub_api(method_override, path, response_body:, content_type: "application/j
     it "normalizes path with leading slash" do
       stub_api("GET", "/languages", response_body: { "content" => [] })
       client.get("languages")
-      expect(WebMock).to have_requested(:post, "#{base_url}/languages")
+      expect(WebMock).to have_requested(:get, "#{base_url}/languages")
     end
   end
 
@@ -86,26 +86,102 @@ def stub_api(method_override, path, response_body:, content_type: "application/j
 
     it "returns raw body for CSV content-type" do
       glossary_id = "gls_1Bc2De3Fg4Hi5Jk6Lm7No"
-      stub_api("GET", "/glossaries/#{glossary_id}/export", response_body: "term,translation\nhello,ciao",
-                                              content_type: "text/csv")
+      stub_request(:get, "#{base_url}/glossaries/#{glossary_id}/export")
+        .with(query: { "content_type" => "csv/table-uni" })
+        .to_return(status: 200, body: "term,translation\nhello,ciao",
+                   headers: { "Content-Type" => "text/csv" })
       result = client.get("/glossaries/#{glossary_id}/export", params: { content_type: "csv/table-uni" })
       expect(result).to eq("term,translation\nhello,ciao")
     end
   end
 
   describe "request headers" do
-    it "sends X-HTTP-Method-Override for get" do
+    it "uses correct HTTP method for get requests" do
       stub_api("GET", "/languages", response_body: { "content" => [] })
       client.get("/languages")
-      expect(WebMock).to have_requested(:post, "#{base_url}/languages")
-        .with(headers: { "X-HTTP-Method-Override" => "GET" })
+      expect(WebMock).to have_requested(:get, "#{base_url}/languages")
     end
 
-    it "sends Authorization with Lara prefix" do
+    it "sends Authorization with Bearer prefix" do
       stub_api("POST", "/translate", response_body: { "content" => {} })
       client.post("/translate", body: { q: "x", target: "it" })
       expect(WebMock).to(have_requested(:post, "#{base_url}/translate")
-        .with { |req| req.headers["Authorization"]&.start_with?("Lara test-id:") })
+        .with { |req| req.headers["Authorization"]&.start_with?("Bearer ") })
+    end
+  end
+
+  describe "authentication" do
+    it "initializes with AuthToken and skips authenticate" do
+      token = Lara::AuthToken.new("jwt-token", "refresh-token")
+      c = described_class.new(token, base_url: base_url)
+      stub_api("GET", "/test", response_body: { "content" => "ok" })
+      result = c.get("/test")
+      expect(result).to eq("ok")
+      expect(WebMock).not_to have_requested(:post, %r{/v2/auth})
+    end
+
+    it "raises ArgumentError for invalid auth_method" do
+      expect { described_class.new("invalid") }.to raise_error(ArgumentError, /auth_method/)
+    end
+
+    it "retries on 401 jwt expired by refreshing token" do
+      stub_request(:post, "#{base_url}/test").to_return(
+        { status: 401,
+          body: { "error" => { "type" => "AuthError", "message" => "jwt expired" } }.to_json,
+          headers: { "Content-Type" => "application/json" } },
+        { status: 200,
+          body: { "content" => "success" }.to_json,
+          headers: { "Content-Type" => "application/json" } }
+      )
+      stub_request(:post, "#{base_url}/v2/auth/refresh").to_return(
+        status: 200,
+        body: { "token" => "new-jwt" }.to_json,
+        headers: { "Content-Type" => "application/json", "x-lara-refresh-token" => "new-refresh" }
+      )
+      result = client.post("/test", body: { q: "x" })
+      expect(result).to eq("success")
+    end
+
+    it "raises non-jwt-expired 401 without retrying" do
+      stub_request(:post, "#{base_url}/test").to_return(
+        status: 401,
+        body: { "error" => { "type" => "AuthError", "message" => "invalid token" } }.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+      expect { client.post("/test", body: { q: "x" }) }.to raise_error(Lara::LaraApiError) do |e|
+        expect(e.status_code).to eq(401)
+        expect(e.message).to include("invalid token")
+      end
+    end
+
+    it "returns raw_response body when raw_response is true" do
+      stub_request(:post, "#{base_url}/v2/images/translate").to_return(
+        status: 200,
+        body: "raw-binary-data",
+        headers: { "Content-Type" => "image/png" }
+      )
+      result = client.post("/v2/images/translate", body: { target: "it" }, raw_response: true)
+      expect(result).to eq("raw-binary-data")
+    end
+  end
+
+  describe "streaming" do
+    it "parses NDJSON streaming response when callback given" do
+      stream_body = "{\"content\":{\"translation\":\"partial\"}}\n{\"content\":{\"translation\":\"Ciao\"}}\n"
+      stub_api("POST", "/translate", response_body: stream_body)
+      results = []
+      client.post("/translate", body: { q: "Hello", target: "it", reasoning: true }) do |partial|
+        results << partial
+      end
+      expect(results.size).to eq(2)
+      expect(results.last).to eq("translation" => "Ciao")
+    end
+
+    it "returns last result from streaming response" do
+      stream_body = "{\"content\":{\"translation\":\"Ciao\"}}\n"
+      stub_api("POST", "/translate", response_body: stream_body)
+      result = client.post("/translate", body: { q: "Hello", target: "it", reasoning: true })
+      expect(result).to eq("translation" => "Ciao")
     end
   end
 end