[refactor api test] simplify: extend EncodingServer from Lame.Encoder

src/encoding-server.coffee

@@ -1,44 +1,41 @@
-stream        = require "stream"
+util          = require "util"
 EvenNicercast = require "./even-nicercast"
+extend        = util._extend
 
 
-class EncodingServer extends stream.PassThrough
-  logPrefix: "(EvenNicercast:EncodingServer)"
+try
+  Lame     = require "lame"
+catch e
+  console.error "lame not installed"
 
-  log:   console.log
-  error: console.error
 
-  # 16-bit signed samples
-  SAMPLE_SIZE: 16
-  CHANNELS:    2
-  SAMPLE_RATE: 44100
+if Lame
+  class EncodingServer extends Lame.Encoder
+    logPrefix: "(EvenNicercast:EncodingServer)"
 
-  BIT_RATE:    128
+    defaults: # 16-bit signed samples
+      channels:   2
+      bitDepth:   16
+      sampleRate: 44100
 
-  constructor: (o = {}, encodingOptions) ->
-    super
+      bitRate:    128
 
-    @[key] = value for key, value of encodingOptions
-    @log   = o.log   if o.log
-    @error = o.error if o.error
-    o.buffer or= @BIT_RATE * 125 * 30 # Kbps * 30s
+    constructor: (o = {}, eo = {}) ->
+      encodingOptions = extend {}, @defaults
+      encodingOptions = extend encodingOptions, eo
 
-    @server = new EvenNicercast o
+      super encodingOptions
 
-    # setup encoder
-    Lame     = require "lame"
-    @encoder = new Lame.Encoder
-      channels:   @CHANNELS
-      bitDepth:   @SAMPLE_SIZE
-      sampleRate: @SAMPLE_RATE
-      bitRate:    @BIT_RATE
+      o.buffer or= @bitRate * 125 * 30 # Kbps * 30s
+      @server = new EvenNicercast o
+      @pipe @server
+      @server.on  "error", @passError
 
-    @pipe @encoder
-    @encoder.pipe @server
+    passError: (err) => @emit "error", err
 
-  setMetadata: -> @server.setMetadata()
-  start: -> @server.start()
-  stop: -> @server.stop()
+    setMetadata: -> @server.setMetadata()
+    start: -> @server.start()
+    stop: -> @server.stop()
 
 
 module.exports = EncodingServer

test/encoding-server.coffee

@@ -10,42 +10,48 @@ describe "EncodingServer", ->
   server = null
   log    = ->
   port   = 7999
-  BIT_RATE = 96
+  bitRate = 96
 
   beforeEach ->
-    server = new Server {port, log}, {BIT_RATE}
+    server = new Server {port, log}, {bitRate}
 
   afterEach ->
     server = null
 
   describe "##constructor", ->
     it "should set defaults", ->
-      defaults = ["log", "error", "SAMPLE_SIZE", "CHANNELS", "SAMPLE_RATE"]
-      expect(server[key]).to.exist for key in defaults
+      defaults = ["channels", "bitDepth", "sampleRate", "bitRate"]
+      expect(server.defaults[key]).to.exist for key in defaults
 
     it "should set options", ->
       options =
-        log:     ->
-        error:   ->
-
         # 16-bit signed samples
-        SAMPLE_SIZE: 16
-        CHANNELS:    1
-        SAMPLE_RATE: 88200
-        BIT_RATE:    BIT_RATE
+        bitDepth:    16
+        channels:    1
+        sampleRate:  88200
+        bitRate:     bitRate
 
       server = new Server null, options
 
       expect(server[key]).to.equal value for key, value of options
 
-    it "should create a Lame encoder", ->
-      expect(server.encoder).to.be.an instanceof Lame.Encoder
+    it "should be a Lame encoder", ->
+      expect(server).to.be.an instanceof Lame.Encoder
 
     it "should create an EvenNicercast server", ->
       expect(server.server).to.be.an instanceof EvenNicer
 
     it "should pass options to the EvenNicercast server", ->
-      expect(server.server.log).to.equal server.log
-      expect(server.server.error).to.equal server.error
+      expect(server.server.log).to.equal log
       expect(server.server.port).to.equal port
-      expect(server.server.buffer).to.equal BIT_RATE * 125 * 30
+      expect(server.server.buffer).to.equal bitRate * 125 * 30
+
+    it "should receive errors from the EvenNicercast server", (done) ->
+      err = new Error "test"
+
+      await
+        server.once "error", defer _err
+        server.server.emit "error", err
+
+      expect(_err).to.equal err
+      done()