Bagaimana saya bisa mengurangi upaya manual untuk membungkus perpustakaan pihak ketiga dengan model objek yang lebih besar?

Seperti penulis pertanyaan ini dari 2012 dan yang ini dari 2013 , saya memiliki perpustakaan pihak ke-3 yang harus saya bungkus untuk menguji aplikasi saya dengan benar. Jawaban teratas menyatakan:

Anda selalu ingin membungkus tipe dan metode pihak ketiga di belakang sebuah antarmuka. Ini bisa membosankan dan menyakitkan. Terkadang Anda dapat menulis pembuat kode atau menggunakan alat untuk melakukan ini.

Dalam kasus saya, perpustakaan adalah untuk model objek dan akibatnya memiliki sejumlah besar kelas dan metode yang perlu dibungkus agar strategi ini berhasil. Di luar sekadar "membosankan dan menyakitkan", ini menjadi penghalang sulit untuk pengujian.

Dalam 4 tahun sejak pertanyaan ini, saya sadar bahwa kerangka kerja isolasi telah berjalan jauh. Pertanyaan saya adalah: apakah sekarang ada cara yang lebih sederhana untuk mencapai efek pembungkus penuh perpustakaan pihak ke-3? Bagaimana saya bisa menghilangkan rasa sakit dari proses ini dan mengurangi upaya manual?

Pertanyaan saya bukanlah duplikat dari pertanyaan yang saya tautkan pada awalnya, karena pertanyaan saya adalah tentang mengurangi upaya pembungkus secara manual. Pertanyaan-pertanyaan lain hanya menanyakan apakah pembungkus itu masuk akal, bukan bagaimana upaya itu dapat dijaga tetap kecil.

Dengan anggapan Anda tidak mencari kerangka kerja yang mengejek, karena sangat ultra-ubiquitous dan mudah ditemukan , ada beberapa hal yang perlu diperhatikan di muka:

1. Ada "tidak pernah" apa pun yang harus "selalu" Anda lakukan.
   Tidak selalu terbaik untuk membungkus perpustakaan pihak ketiga. Jika aplikasi Anda secara intrinsik tergantung pada perpustakaan, atau jika itu benar-benar dibangun di sekitar satu atau dua perpustakaan inti, jangan buang waktu Anda membungkusnya. Jika perpustakaan berubah, aplikasi Anda harus tetap berubah .
2. Boleh saja menggunakan tes integrasi.
   Ini terutama berlaku di sekitar batas yang stabil, intrinsik untuk aplikasi Anda, atau tidak dapat dengan mudah diejek. Jika syarat-syarat itu terpenuhi, membungkus dan mengejek akan menjadi rumit dan membosankan. Dalam hal ini, saya akan menghindari keduanya: jangan membungkus dan tidak mengejek; tulis saja tes integrasi. (Jika pengujian otomatis adalah tujuan.)
3. Alat dan kerangka kerja tidak dapat menghilangkan kompleksitas logis.
   Pada prinsipnya, alat hanya bisa mengurangi boilerplate. Tetapi, tidak ada algoritma yang dapat diotomatisasi untuk mengambil antarmuka yang kompleks dan membuatnya mudah - apalagi menggunakan antarmuka X dan mengadaptasinya sesuai dengan kebutuhan Anda. (Hanya Anda yang tahu bahwa algoritma!) Jadi, sementara ada diragukan lagi alat yang dapat menghasilkan pembungkus tipis, saya sarankan bahwa mereka belum di mana-mana karena, pada akhirnya, Anda masih perlu untuk kode hanya cerdas, dan karena itu secara manual, terhadap antarmuka bahkan jika itu tersembunyi di balik pembungkus.

Yang mengatakan, ada taktik yang dapat Anda gunakan dalam banyak bahasa untuk menghindari merujuk langsung ke kelas. Dan dalam beberapa kasus, Anda dapat "berpura-pura" antarmuka atau pembungkus tipis yang sebenarnya tidak ada. Dalam C #, misalnya, saya akan pergi salah satu dari dua rute:

1. Gunakan pabrik dan pengetikan implisit .

Anda dapat menghindari upaya membungkus sepenuhnya kelas yang kompleks dengan kombo kecil ini:

// "factory"
class PdfDocumentFactory {
  public static ExternalPDFLibraryDocument Build() {
    return new ExternalPDFLibraryDocument();
  }
}

// code that uses the factory.
class CoreBusinessEntity {
  public void DoImportantThings() {
    var doc = PdfDocumentFactory.Build();

    // ... i have no idea what your lib does, so, I'm making stuff but.
    // but, you can do whatever you want here without explicitly
    // referring to the library's actual types.
    doc.addHeader("Wee");
    doc.getAllText().makeBiggerBy(4).makeBold().makeItalic();
    return doc.exportBinaryStreamOrSomething();
  }
}

Jika Anda dapat menghindari menyimpan objek-objek ini sebagai anggota, baik melalui pendekatan yang lebih "fungsional" atau dengan menyimpannya dalam kamus (atau apa pun ), pendekatan ini memiliki manfaat memeriksa tipe waktu kompilasi tanpa entitas bisnis inti Anda perlu tahu persis kelas apa yang mereka kerjakan.

Yang diperlukan hanyalah bahwa, pada waktu kompilasi, kelas yang dikembalikan oleh pabrik Anda sebenarnya memiliki metode yang digunakan objek bisnis Anda.

2. Gunakan pengetikan dinamis .

Ini berada dalam nada yang sama dengan menggunakan pengetikan tersirat , tetapi melibatkan pengorbanan lain: Anda kehilangan pemeriksaan tipe kompilasi dan mendapatkan kemampuan untuk menambahkan dependensi eksternal secara anonim sebagai anggota kelas dan menyuntikkan dependensi Anda.

class CoreBusinessEntity {
  dynamic Doc;

  public void InjectDoc(dynamic Doc) {
    Doc = doc;
  }

  public void DoImortantThings() {
    Doc.addHeader("Wee");
    Doc.getAllText().makeBiggerBy(4).makeBold().makeItalic();
    return Doc.exportBinaryStreamOrSomething();
  }
}

Dengan kedua taktik ini, ketika tiba saatnya untuk mengejek ExternalPDFLibraryDocument, seperti yang saya katakan sebelumnya, Anda memiliki beberapa pekerjaan yang harus dilakukan - tetapi, itu adalah pekerjaan yang perlu Anda lakukan juga . Dan, dengan konstruksi ini, Anda telah menghindari mendefinisikan 100-an kelas bungkus kecil tipis. Anda cukup menggunakan perpustakaan tanpa melihatnya langsung - sebagian besar.

Dengan semua yang dikatakan, ada tiga alasan besar yang saya masih akan mempertimbangkan secara eksplisit membungkus perpustakaan pihak ketiga - tidak ada yang akan mengisyaratkan menggunakan alat atau kerangka kerja:

1. Perpustakaan spesifik tidak intrinsik ke aplikasi.
2. Akan sangat mahal untuk menukar tanpa membungkusnya.
3. Saya tidak suka API itu sendiri.

Jika saya tidak memiliki masalah level di ketiga area tersebut, Anda tidak melakukan upaya signifikan untuk menyelesaikannya. Dan, jika Anda memiliki kekhawatiran di ketiga area, pembungkus tipis yang dibuat secara otomatis tidak akan membantu.

Jika Anda telah memutuskan untuk membungkus pustaka, penggunaan waktu Anda yang paling efisien dan efektif adalah membangun aplikasi Anda terhadap antarmuka yang Anda inginkan ; tidak menentang API yang ada.

Dengan kata lain, perhatikan nasihat klasik: Tunda setiap keputusan yang Anda bisa. Bangun "inti" aplikasi Anda terlebih dahulu. Kode terhadap antarmuka yang pada akhirnya akan melakukan apa yang Anda inginkan, yang pada akhirnya akan dipenuhi oleh "hal periferal" yang belum ada. Jembatan kesenjangan yang diperlukan.

Upaya ini mungkin tidak terasa seperti menghemat waktu; tetapi jika Anda merasa perlu pembungkus, ini adalah cara paling efisien untuk melakukannya dengan aman.

Pikirkan seperti ini.

Anda perlu kode terhadap pustaka ini di beberapa sudut gelap kode Anda - bahkan jika sudah selesai. Jika Anda mengejek perpustakaan selama pengujian, ada upaya manual yang tidak dapat dihindari di sana - bahkan jika sudah selesai. Tapi, itu tidak berarti Anda harus secara langsung mengakui perpustakaan itu dengan nama di sebagian besar aplikasi Anda.

TLDR

Jika perpustakaan layak untuk dibungkus, gunakan taktik untuk menghindari rujukan luas, langsung ke perpustakaan pihak ke-3 Anda, tetapi jangan mengambil jalan pintas untuk menghasilkan pembungkus tipis. Bangun logika bisnis Anda terlebih dahulu, pertimbangkan antarmuka Anda, dan jalankan adapter Anda secara organik, sesuai kebutuhan.

Dan, jika itu yang terjadi, jangan takut dengan tes integrasi. Mereka sedikit fuzzier, tetapi mereka masih menawarkan bukti kode kerja, dan mereka masih dapat dengan mudah dibuat untuk menjaga regresi.

Jangan unit menguji kode itu. Tuliskan tes integrasi sebagai gantinya. Dalam beberapa kasus, unit pengujian, mengejek, adalah membosankan dan menyakitkan. Parit tes unit dan tulis tes integrasi yang benar-benar membuat vendor berteriak.

Catatan, tes ini harus dijalankan setelah penyebaran sebagai aktivitas otomatis pasca penempatan. Mereka tidak dijalankan sebagai bagian dari unit test atau bagian dari proses build.

Terkadang tes integrasi lebih cocok daripada tes unit di bagian tertentu aplikasi Anda. Lingkaran yang harus dilalui seseorang untuk membuat kode "dapat diuji" kadang-kadang dapat merugikan.

Seperti yang saya mengerti, diskusi ini berfokus pada peluang untuk otomatisasi pembuatan wrapper daripada membungkus ide dan pedoman implementasi. Saya akan mencoba abstrak dari ide karena sudah ada banyak hal di sini.

Saya melihat bahwa kami bermain-main dengan teknologi .NET, oleh karena itu kami memiliki kemampuan refleksi yang kuat di tangan kami. Anda dapat mempertimbangkan:

1. Alat seperti .NET Wrapper Class Generator . Saya belum pernah menggunakan alat itu dan saya tahu itu beroperasi pada tumpukan teknologi warisan, tapi mungkin untuk kasus Anda itu akan cocok. Tentu saja, kualitas kode, dukungan untuk Inversi Ketergantungan dan Segregasi Antarmuka harus diselidiki secara terpisah. Mungkin ada alat lain seperti itu tetapi saya tidak banyak mencari.
2. Menulis alat Anda sendiri yang akan mencari dalam rujukan referensi untuk metode / antarmuka publik dan melakukan pemetaan dan pembuatan kode. Sumbangan bagi komunitas akan lebih dari diterima!
3. Jika .NET bukan kasing ... mungkin lihat di sini .

Saya percaya bahwa otomatisasi semacam itu mungkin merupakan titik dasar, tetapi bukan solusi akhir. Refactoring kode manual akan diperlukan ... atau dalam kasus terburuk redesign karena saya sepenuhnya setuju dengan apa yang ditulis svidgen:

Bangun aplikasi Anda terhadap antarmuka yang Anda inginkan; tidak menentang API pihak ke-3.

Ikuti panduan ini saat membuat perpustakaan pembungkus:

• tampilkan hanya sebagian kecil dari perpustakaan pihak ketiga yang Anda butuhkan saat ini (dan perluas sesuai permintaan)
• menjaga pembungkus setipis mungkin (tidak ada logika yang dimiliki di sana).