क्या यूनिट परीक्षण एसक्यूएल संग्रहीत प्रक्रियाओं में किसी को भी कोई सफलता मिली है?

हमने पाया है कि हमारे सी #/सी ++ कोड के लिए लिखे गए यूनिट परीक्षणों ने वास्तव में भुगतान किया है। लेकिन हमारे पास अभी भी संग्रहीत प्रक्रियाओं में हजारों लाइनों का तर्क तर्क है, जो कि हमारे उत्पाद को बड़ी संख्या में उपयोगकर्ताओं के लिए लुढ़काते समय केवल क्रोध में परीक्षण किया जाता है।

इससे भी बदतर यह है कि एसपी के बीच अस्थायी तालिकाओं को पार करते समय प्रदर्शन की वजह से इन संग्रहित प्रक्रियाओं में से कुछ बहुत लंबे समय तक समाप्त हो जाते हैं। इसने हमें कोड को सरल बनाने के लिए रिफैक्टरिंग से रोका है।

हमने अपनी कुछ प्रमुख संग्रहीत प्रक्रियाओं (मुख्य रूप से प्रदर्शन का परीक्षण करने) के आसपास इकाई परीक्षणों के निर्माण में कई प्रयास किए हैं, लेकिन पाया है कि इन परीक्षणों के लिए परीक्षण डेटा सेट करना वास्तव में कठिन है। उदाहरण के लिए, हम टेस्ट डेटाबेस के चारों ओर प्रतिलिपि बनाते हैं। इसके अलावा, परीक्षणों को बदलने के लिए वास्तव में संवेदनशील होने का अंत होता है, और यहां तक ​​कि संग्रहित प्रो में सबसे छोटा परिवर्तन भी होता है। या तालिका में परीक्षणों में बड़ी संख्या में परिवर्तन की आवश्यकता होती है। तो इन डेटाबेस परीक्षणों के कारण कई बार टूटने के बाद अंतःस्थापित होने में असफल रहा, हमें बस उन्हें निर्माण प्रक्रिया से बाहर खींचना पड़ा।

तो, मेरे प्रश्नों का मुख्य भाग यह है: क्या किसी ने कभी भी अपनी संग्रहीत प्रक्रियाओं के लिए यूनिट परीक्षण सफलतापूर्वक लिखे हैं?

मेरे प्रश्नों का दूसरा भाग यह है कि यूनिट परीक्षण linq के साथ आसान/आसान होगा?

मैं सोच रहा था कि टेस्ट डेटा की टेबल सेट करने के बजाय, आप बस टेस्ट ऑब्जेक्ट्स का संग्रह बना सकते हैं, और ऑब्जेक्ट्स में लिनक में अपने लिनक कोड का परीक्षण कर सकते हैं? परिस्थिति? (मैं linq के लिए बिल्कुल नया हूँ इसलिए पता नहीं है कि यह भी काम करेगा या नहीं)

0
ro fr bn

16 उत्तर

क्या आपने DBUnit की कोशिश की है? यह आपके सी # कोड के माध्यम से जाने की आवश्यकता के बिना, आपके डेटाबेस, और बस अपने डेटाबेस का परीक्षण करने के लिए डिज़ाइन किया गया है।

0
जोड़ा

LINQ केवल तभी इसे सरल करेगा यदि आप अपनी संग्रहीत प्रक्रियाओं से तर्क हटाते हैं और इसे linq प्रश्नों के रूप में पुन: कार्यान्वित करते हैं। जो निश्चित रूप से परीक्षण करने के लिए और अधिक मजबूत और आसान होगा। हालांकि, ऐसा लगता है जैसे आपकी आवश्यकताओं को रोक देगा।

टीएल; डीआर: आपके डिजाइन में समस्याएं हैं।

0
जोड़ा

कोड को फिर से कारक करने का एक विकल्प (मैं एक बदसूरत हैक स्वीकार करूंगा) इसे सीपीपी (सी प्रीप्रोसेसर) एम 4 (कभी कोशिश नहीं की) या इसी तरह के माध्यम से उत्पन्न करना होगा। मेरे पास एक परियोजना है जो सिर्फ यही कर रही है और यह वास्तव में अधिकतर काम करने योग्य है।

एकमात्र मामला मुझे लगता है कि यह वैध हो सकता है 1) केएलओसी + संग्रहीत प्रक्रियाओं के विकल्प के रूप में और 2) और यह मेरे मामले है, जब परियोजना का बिंदु यह देखना है कि कितना दूर (पागल में) आप एक तकनीक को धक्का दे सकते हैं।

0
जोड़ा

हम प्रत्येक परीक्षण के बीच रोलबैक परिवर्तनों के लिए डेटाफ़्रेश का उपयोग करते हैं, फिर परीक्षण स्पॉक्स अपेक्षाकृत आसान है।

कोड कवरेज टूल की अभी भी कमी है।

0
जोड़ा

मैं थोड़ी देर पहले इस मुद्दे पर भाग गया और पाया कि अगर मैंने डेटा एक्सेस के लिए एक साधारण सार आधार वर्ग बनाया है जिसने मुझे कनेक्शन और लेनदेन इंजेक्ट करने की इजाजत दी है, तो मैं यूनिट को अपने स्पॉक्स का परीक्षण कर सकता हूं ताकि यह देखने के लिए कि उन्होंने SQL में काम किया है या नहीं। उन्हें करने के लिए कहा और फिर रोलबैक ताकि डीबी में कोई भी परीक्षण डेटा छोड़ा न जाए।

यह सामान्य से बेहतर महसूस करता है "मेरे टेस्ट डीबी को सेट करने के लिए एक स्क्रिप्ट चलाएं, फिर परीक्षण चलाने के बाद जंक/टेस्ट डेटा की सफाई करें"। यह यूनिट परीक्षण के करीब भी महसूस किया गया क्योंकि इन परीक्षणों को चलाने से पहले इन परीक्षणों को अकेले चलाया जा सकता था "डीबी में सब कुछ होना चाहिए 'बस इतना ही है।

यहां डेटा पहुंच के लिए उपयोग की जाने वाली सार आधार वर्ग का एक स्निपेट है

Public MustInherit Class Repository(Of T As Class)
    Implements IRepository(Of T)

    Private mConnectionString As String = ConfigurationManager.ConnectionStrings("Northwind.ConnectionString").ConnectionString
    Private mConnection As IDbConnection
    Private mTransaction As IDbTransaction

    Public Sub New()
        mConnection = Nothing
        mTransaction = Nothing
    End Sub

    Public Sub New(ByVal connection As IDbConnection, ByVal transaction As IDbTransaction)
        mConnection = connection
        mTransaction = transaction
    End Sub

    Public MustOverride Function BuildEntity(ByVal cmd As SqlCommand) As List(Of T)

    Public Function ExecuteReader(ByVal Parameter As Parameter) As List(Of T) Implements IRepository(Of T).ExecuteReader
        Dim entityList As List(Of T)
        If Not mConnection Is Nothing Then
            Using cmd As SqlCommand = mConnection.CreateCommand()
                cmd.Transaction = mTransaction
                cmd.CommandType = Parameter.Type
                cmd.CommandText = Parameter.Text
                If Not Parameter.Items Is Nothing Then
                    For Each param As SqlParameter In Parameter.Items
                        cmd.Parameters.Add(param)
                    Next
                End If
                entityList = BuildEntity(cmd)
                If Not entityList Is Nothing Then
                    Return entityList
                End If
            End Using
        Else
            Using conn As SqlConnection = New SqlConnection(mConnectionString)
                Using cmd As SqlCommand = conn.CreateCommand()
                    cmd.CommandType = Parameter.Type
                    cmd.CommandText = Parameter.Text
                    If Not Parameter.Items Is Nothing Then
                        For Each param As SqlParameter In Parameter.Items
                            cmd.Parameters.Add(param)
                        Next
                    End If
                    conn.Open()
                    entityList = BuildEntity(cmd)
                    If Not entityList Is Nothing Then
                        Return entityList
                    End If
                End Using
            End Using
        End If

        Return Nothing
    End Function
End Class

अगला आप उत्पादों की सूची प्राप्त करने के लिए उपर्युक्त आधार का उपयोग करके एक नमूना डेटा एक्सेस क्लास देखेंगे

Public Class ProductRepository
    Inherits Repository(Of Product)
    Implements IProductRepository

    Private mCache As IHttpCache

    'This const is what you will use in your app
    Public Sub New(ByVal cache As IHttpCache)
        MyBase.New()
        mCache = cache
    End Sub

    'This const is only used for testing so we can inject a connectin/transaction and have them roll'd back after the test
    Public Sub New(ByVal cache As IHttpCache, ByVal connection As IDbConnection, ByVal transaction As IDbTransaction)
        MyBase.New(connection, transaction)
        mCache = cache
    End Sub

    Public Function GetProducts() As System.Collections.Generic.List(Of Product) Implements IProductRepository.GetProducts
        Dim Parameter As New Parameter()
        Parameter.Type = CommandType.StoredProcedure
        Parameter.Text = "spGetProducts"
        Dim productList As List(Of Product)
        productList = MyBase.ExecuteReader(Parameter)
        Return productList
    End Function

    'This function is used in each class that inherits from the base data access class so we can keep all the boring left-right mapping code in 1 place per object
    Public Overrides Function BuildEntity(ByVal cmd As System.Data.SqlClient.SqlCommand) As System.Collections.Generic.List(Of Product)
        Dim productList As New List(Of Product)
        Using reader As SqlDataReader = cmd.ExecuteReader()
            Dim product As Product
            While reader.Read()
                product = New Product()
                product.ID = reader("ProductID")
                product.SupplierID = reader("SupplierID")
                product.CategoryID = reader("CategoryID")
                product.ProductName = reader("ProductName")
                product.QuantityPerUnit = reader("QuantityPerUnit")
                product.UnitPrice = reader("UnitPrice")
                product.UnitsInStock = reader("UnitsInStock")
                product.UnitsOnOrder = reader("UnitsOnOrder")
                product.ReorderLevel = reader("ReorderLevel")
                productList.Add(product)
            End While
            If productList.Count > 0 Then
                Return productList
            End If
        End Using
        Return Nothing
    End Function
End Class

और अब आपके यूनिट टेस्ट में आप एक बहुत ही सरल बेस क्लास से भी उत्तराधिकारी हो सकते हैं जो आपके सेटअप/रोलबैक काम करता है - या प्रति यूनिट परीक्षण आधार पर रखें

नीचे उपयोग किया गया सरल परीक्षण बेस क्लास है

Imports System.Configuration
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.VisualStudio.TestTools.UnitTesting

Public MustInherit Class TransactionFixture
    Protected mConnection As IDbConnection
    Protected mTransaction As IDbTransaction
    Private mConnectionString As String = ConfigurationManager.ConnectionStrings("Northwind.ConnectionString").ConnectionString

     _
    Public Sub CreateConnectionAndBeginTran()
        mConnection = New SqlConnection(mConnectionString)
        mConnection.Open()
        mTransaction = mConnection.BeginTransaction()
    End Sub

     _
    Public Sub RollbackTranAndCloseConnection()
        mTransaction.Rollback()
        mTransaction.Dispose()
        mConnection.Close()
        mConnection.Dispose()
    End Sub
End Class

और अंत में - नीचे उस टेस्ट बेस क्लास का उपयोग करके एक साधारण परीक्षण है जो यह दिखाता है कि सभी स्पॉक्स अपने काम करते हैं और यह कि आपका ado.net कोड बाएं-दाएं मैपिंग सही तरीके से करता है, पूरे सीआरयूडी चक्र का परीक्षण कैसे करें

मुझे पता है कि यह उपरोक्त डेटा एक्सेस नमूने में उपयोग किए गए "spGetProducts" sproc का परीक्षण नहीं करता है, लेकिन आपको इकाई परीक्षण sprocs के लिए इस दृष्टिकोण के पीछे की शक्ति देखना चाहिए

Imports SampleApplication.Library
Imports System.Collections.Generic
Imports Microsoft.VisualStudio.TestTools.UnitTesting

 _
Public Class ProductRepositoryUnitTest
    Inherits TransactionFixture

    Private mRepository As ProductRepository

     _
    Public Sub Should-Insert-Update-And-Delete-Product()
        mRepository = New ProductRepository(New HttpCache(), mConnection, mTransaction)
        '** Create a test product to manipulate throughout **'
        Dim Product As New Product()
        Product.ProductName = "TestProduct"
        Product.SupplierID = 1
        Product.CategoryID = 2
        Product.QuantityPerUnit = "10 boxes of stuff"
        Product.UnitPrice = 14.95
        Product.UnitsInStock = 22
        Product.UnitsOnOrder = 19
        Product.ReorderLevel = 12
        '** Insert the new product object into SQL using your insert sproc **'
        mRepository.InsertProduct(Product)
        '** Select the product object that was just inserted and verify it does exist **'
        '** Using your GetProductById sproc **'
        Dim Product2 As Product = mRepository.GetProduct(Product.ID)
        Assert.AreEqual("TestProduct", Product2.ProductName)
        Assert.AreEqual(1, Product2.SupplierID)
        Assert.AreEqual(2, Product2.CategoryID)
        Assert.AreEqual("10 boxes of stuff", Product2.QuantityPerUnit)
        Assert.AreEqual(14.95, Product2.UnitPrice)
        Assert.AreEqual(22, Product2.UnitsInStock)
        Assert.AreEqual(19, Product2.UnitsOnOrder)
        Assert.AreEqual(12, Product2.ReorderLevel)
        '** Update the product object **'
        Product2.ProductName = "UpdatedTestProduct"
        Product2.SupplierID = 2
        Product2.CategoryID = 1
        Product2.QuantityPerUnit = "a box of stuff"
        Product2.UnitPrice = 16.95
        Product2.UnitsInStock = 10
        Product2.UnitsOnOrder = 20
        Product2.ReorderLevel = 8
        mRepository.UpdateProduct(Product2) '**using your update sproc
        '** Select the product object that was just updated to verify it completed **'
        Dim Product3 As Product = mRepository.GetProduct(Product2.ID)
        Assert.AreEqual("UpdatedTestProduct", Product2.ProductName)
        Assert.AreEqual(2, Product2.SupplierID)
        Assert.AreEqual(1, Product2.CategoryID)
        Assert.AreEqual("a box of stuff", Product2.QuantityPerUnit)
        Assert.AreEqual(16.95, Product2.UnitPrice)
        Assert.AreEqual(10, Product2.UnitsInStock)
        Assert.AreEqual(20, Product2.UnitsOnOrder)
        Assert.AreEqual(8, Product2.ReorderLevel)
        '** Delete the product and verify it does not exist **'
        mRepository.DeleteProduct(Product3.ID)
        '** The above will use your delete product by id sproc **'
        Dim Product4 As Product = mRepository.GetProduct(Product3.ID)
        Assert.AreEqual(Nothing, Product4)
    End Sub

End Class

मुझे पता है कि यह एक लंबा उदाहरण है, लेकिन यह डेटा एक्सेस काम के लिए एक पुन: प्रयोज्य वर्ग बनाने में मदद करता है, और फिर भी मेरे परीक्षण के लिए एक और पुन: प्रयोज्य वर्ग है इसलिए मुझे सेटअप/टियरडाउन काम बार-बार करने की ज़रूरत नहीं थी;)

0
जोड़ा

लेकिन मुझे लगता है कि आप वास्तव में प्रदर्शन के साथ अधिक चिंतित हैं, जो वास्तव में यूनिट परीक्षण की रक्षा नहीं है। यूनिट परीक्षणों को काफी परमाणु माना जाता है और प्रदर्शन के बजाए व्यवहार की जांच करना है। और उस स्थिति में आपको निश्चित रूप से क्वेरी योजनाओं की जांच करने के लिए उत्पादन-वर्ग भार की आवश्यकता होगी।

मुझे लगता है कि यहां दो अलग-अलग परीक्षण क्षेत्र हैं: प्रदर्शन, और संग्रहीत प्रक्रियाओं के वास्तविक तर्क।

मैंने अतीत में डीबी प्रदर्शन का परीक्षण करने का उदाहरण दिया और, शुक्र है, हम उस बिंदु पर पहुंच गए हैं जहां प्रदर्शन काफी अच्छा है।

मैं पूरी तरह से सहमत हूं कि डेटाबेस में सभी व्यावसायिक तर्कों की स्थिति खराब है, लेकिन यह ऐसा कुछ है जिसे हमने अपने अधिकांश डेवलपर्स कंपनी में शामिल होने से पहले विरासत में मिला है।

हालांकि, अब हम अपनी नई सुविधाओं के लिए वेब सेवा मॉडल अपना रहे हैं, और हम जितना संभव हो सके संग्रहित प्रक्रियाओं से बचने की कोशिश कर रहे हैं, सी # कोड में तर्क रखते हुए और डेटाबेस में SQLCommands को फायर कर रहे हैं (हालांकि linq अब होगा पसंदीदा विधि)। मौजूदा एसपी का अभी भी कुछ उपयोग है, इसलिए मैं पीछे से निरीक्षण इकाई के बारे में सोच रहा था।

0
जोड़ा

I am assuming that you want unit testing in MSSQL. Looking at DBUnit there are some limitations in it's support for MSSQL. It doesn't support NVarChar for instance. Here are some real users and their problems with DBUnit.

0
जोड़ा

संग्रहित प्रक्रियाओं का परीक्षण करने की कुंजी एक ऐसी स्क्रिप्ट लिख रही है जो संग्रहित प्रक्रियाओं के दौरान लगातार व्यवहार में परिणामस्वरूप डेटा के साथ रिक्त डेटाबेस को पॉप्युलेट करता है।

मुझे अपने वोट को संग्रहित प्रक्रियाओं का भारी समर्थन करने और अपने व्यापार तर्क को रखने के लिए रखना है जहां मैं (और अधिकांश डीबीए) सोचता हूं कि यह डेटाबेस में है।

मुझे पता है कि हम सॉफ़्टवेयर इंजीनियरों के रूप में हमारे पसंदीदा भाषा में लिखे गए सुंदर रूप से प्रतिक्रिया किए गए कोड चाहते हैं, हमारे सभी महत्वपूर्ण तर्कों को शामिल करने के लिए, लेकिन उच्च मात्रा प्रणाली में प्रदर्शन की वास्तविकताओं और डेटा अखंडता की महत्वपूर्ण प्रकृति के लिए हमें कुछ समझौता करने की आवश्यकता है । एसक्यूएल कोड बदसूरत, दोहराव और परीक्षण करने में कठोर हो सकता है, लेकिन मैं क्वेरी के डिज़ाइन पर पूर्ण नियंत्रण किए बिना डेटाबेस को ट्यून करने की कठिनाई की कल्पना नहीं कर सकता।

स्वीकार्य समय में चीजों को चलाने के लिए, मुझे अक्सर डेटा मॉडल में परिवर्तन शामिल करने के लिए प्रश्नों को पूरी तरह से फिर से डिजाइन करने के लिए मजबूर किया जाता है। संग्रहीत प्रक्रियाओं के साथ, मैं आश्वस्त कर सकता हूं कि परिवर्तन कॉलर के लिए पारदर्शी होंगे, क्योंकि संग्रहीत प्रक्रिया इस तरह के उत्कृष्ट encapsulation प्रदान करता है।

0
जोड़ा
आप अपने snswer के साथ trolling कर रहे थे, है ना? क्या व्यवसाय तर्क एक अधिभारित अर्थ में प्रयोग किया जाता है? तो आप एकीकरण या उच्च स्टैक परीक्षण के साथ अपने तर्क का परीक्षण कैसे करेंगे? मुझे स्पॉक्स को सरल रखने और कोड में लॉजिकल लिफ्टिंग करने में कहीं अधिक सफलता मिली है। डीबी में सभी व्यावसायिक तर्कों को सुनिश्चित करने के लिए मुझे हास्यास्पद घोंसला वाले स्पॉक्स और कार्यों के साथ भयानक अनुभव हुए हैं। मेरे लिए धन्यवाद नहीं।
जोड़ा लेखक brumScouse, स्रोत

मैं गरीब आदमी का यूनिट परीक्षण करता हूं। यदि मैं आलसी हूं, तो परीक्षण संभावित रूप से समस्याग्रस्त पैरामीटर मानों के साथ केवल कुछ वैध आमंत्रण है।

/*

--setup
Declare @foo int Set @foo = (Select top 1 foo from mytable)

--test
execute wish_I_had_more_Tests @foo

--look at rowcounts/look for errors
If @@rowcount=1 Print 'Ok!' Else Print 'Nokay!'

--Teardown
Delete from mytable where foo = @foo
*/
create procedure wish_I_had_more_Tests
as
select....
0
जोड़ा

यदि आप इस तरह के कोड के बारे में सोचते हैं कि यूनिट परीक्षण को बढ़ावा देने के लिए प्रेरित किया जाता है: छोटे अत्यधिक-संयोजी और कम-युग्मित दिनचर्या, तो आपको यह देखने में सक्षम होना चाहिए कि समस्या का कम से कम हिस्सा कहां हो सकता है।

मेरी सनकी दुनिया में, संग्रहित प्रक्रियाएं आरडीबीएमएस की दुनिया के लंबे समय से प्रयास करने का प्रयास करती हैं ताकि आप अपने व्यापार प्रसंस्करण को डेटाबेस में स्थानांतरित कर सकें, जो समझ में आता है कि सर्वर लाइसेंस लागत प्रोसेसर गिनती जैसी चीजों से संबंधित होती है। जितना अधिक सामान आप अपने डेटाबेस के अंदर चलाते हैं, उतना ही वे आपके द्वारा बनाए जाते हैं।

लेकिन मुझे लगता है कि आप वास्तव में प्रदर्शन के साथ अधिक चिंतित हैं, जो वास्तव में इकाई परीक्षण की रक्षा नहीं है। यूनिट परीक्षणों को काफी परमाणु माना जाता है और प्रदर्शन के बजाए व्यवहार की जांच करना है। और उस स्थिति में आप निश्चित रूप से क्वेरी योजनाओं की जांच के लिए उत्पादन-वर्ग भार की आवश्यकता होगी।

मुझे लगता है कि आपको परीक्षण वातावरण की एक अलग श्रेणी की आवश्यकता है। मैं उत्पादन की एक प्रति सबसे सरल के रूप में सुझाव दूंगा, मानते हुए सुरक्षा एक मुद्दा नहीं है। फिर प्रत्येक उम्मीदवार के रिलीज के लिए, आप पिछले संस्करण से शुरू करते हैं, अपनी रिलीज प्रक्रियाओं का उपयोग करके माइग्रेट करें (जो उन्हें साइड इफेक्ट के रूप में एक अच्छा परीक्षण देगा) और अपना समय चलाएं।

ऐसा कुछ।

0
जोड़ा

किसी भी प्रकार के डेटा से संबंधित प्रोग्रामिंग इकाई परीक्षण के साथ समस्या यह है कि आपके पास शुरू करने के लिए परीक्षण डेटा का विश्वसनीय सेट होना चाहिए। बहुत कुछ संग्रहीत प्रो की जटिलता और यह क्या करता है पर निर्भर करता है। एक बहुत ही जटिल प्रक्रिया के लिए इकाई परीक्षण स्वचालित करना बहुत कठिन होगा जो कई तालिकाओं को संशोधित करता है।

कुछ अन्य पोस्टर्स ने मैन्युअल रूप से परीक्षण करने के स्वचालित करने के कुछ सरल तरीकों का उल्लेख किया है, और कुछ टूल जो आप SQL सर्वर के साथ उपयोग कर सकते हैं। ओरेकल पक्ष पर, पीएल/एसक्यूएल गुरु स्टीवन फेयरेस्टीन ने पीएल/एसक्यूएल संग्रहीत प्रक्रियाओं के लिए एक मुफ्त इकाई परीक्षण उपकरण पर काम किया जिसे utPLSQL कहा जाता है।

हालांकि, उन्होंने उस प्रयास को छोड़ दिया और फिर पीएल/एसक्यूएल के लिए क्वेस्ट कोड कोडर के साथ वाणिज्यिक चला गया। क्वेस्ट एक मुफ्त डाउनलोड करने योग्य परीक्षण संस्करण प्रदान करता है। मैं इसे आजमाने की कगार पर हूं; मेरी समझ यह है कि परीक्षण ढांचे की स्थापना में ओवरहेड की देखभाल करने में अच्छा होता है ताकि आप केवल परीक्षणों पर ध्यान केंद्रित कर सकें, और यह परीक्षण रखता है ताकि आप उन्हें रिग्रेशन परीक्षण में पुन: उपयोग कर सकें, महान लाभों में से एक परीक्षण संचालित विकास। इसके अलावा, यह केवल आउटपुट वैरिएबल की जांच करने के अलावा अच्छा होना चाहिए और इसमें डेटा परिवर्तनों को सत्यापित करने के लिए प्रावधान है, लेकिन मुझे अभी भी नज़दीक दिखना है। मैंने सोचा कि ओरेकल उपयोगकर्ताओं के लिए यह जानकारी मूल्य का हो सकती है।

0
जोड़ा

ओह लड़का। sprocs खुद को (स्वचालित) इकाई परीक्षण करने के लिए उधार नहीं देते हैं। मैं टी-एसक्यूएल बैच फाइलों में परीक्षण लिखकर और प्रिंट स्टेटमेंट्स और परिणामों के आउटपुट की जांच करके मेरे जटिल स्पॉक्स को "यूनिट टेस्ट" का क्रमबद्ध करता हूं।

0
जोड़ा

आप डेटाबेस पेशेवरों के लिए विजुअल स्टूडियो भी आज़मा सकते हैं। यह मुख्य रूप से परिवर्तन प्रबंधन के बारे में है लेकिन परीक्षण डेटा और यूनिट परीक्षणों के निर्माण के लिए भी उपकरण हैं।

यह बहुत महंगा है।

0
जोड़ा

अच्छा प्रश्न।

मुझे समान समस्याएं हैं, और मैंने कम से कम प्रतिरोध का मार्ग लिया है (वैसे भी, मेरे लिए)।

अन्य समाधानों का एक गुच्छा है, जिन्हें अन्य ने उल्लेख किया है। उनमें से कई दूसरों के लिए बेहतर/अधिक शुद्ध/अधिक उपयुक्त हैं।

मैं पहले से ही अपने सी # का परीक्षण करने के लिए Testdriven.NET/MbUnit का उपयोग कर रहा था, इसलिए मैंने बस उस ऐप द्वारा उपयोग की गई संग्रहीत प्रक्रियाओं को कॉल करने के लिए प्रत्येक प्रोजेक्ट में परीक्षण जोड़े।

मैं जानता हूँ मैं जानता हूँ। यह भयानक लगता है, लेकिन मुझे जो चाहिए वह कुछ परीक्षण के साथ जमीन से उतरना है, और वहां से जाना है। इस दृष्टिकोण का अर्थ है कि हालांकि मेरा कवरेज कम है, मैं एक ही समय में कुछ संग्रहीत प्रोसेस का परीक्षण कर रहा हूं क्योंकि मैं कोड का परीक्षण कर रहा हूं जो उन्हें कॉल करेगा। इसके लिए कुछ तर्क है।

0
जोड़ा

हम सी # कोड का परीक्षण करते हैं जो एसपी को कॉल करता है।
हमने स्वच्छ परीक्षण डेटाबेस बनाने, स्क्रिप्ट तैयार की हैं।
और बड़े हम परीक्षण परीक्षण के दौरान संलग्न और अलग करते हैं।
इन परीक्षणों में घंटों लग सकते हैं, लेकिन मुझे लगता है कि यह इसके लायक है।

0
जोड़ा

मैं मूल पोस्टर के समान स्थिति में हूं। यह प्रदर्शन बनाम टेस्टेबिलिटी के लिए नीचे आता है। मेरी पूर्वाग्रह टेस्टेबिलिटी की ओर है (इसे काम करें, इसे सही बनाएं, इसे तेज बनाएं), जो डेटाबेस से व्यवसाय तर्क को बाहर रखने का सुझाव देता है। डेटाबेस में न केवल परीक्षण ढांचे, कोड फैक्टरिंग संरचनाएं, और जावा जैसे भाषाओं में कोड विश्लेषण और नेविगेशन टूल की कमी है, लेकिन अत्यधिक फैक्टर डेटाबेस कोड भी धीमा है (जहां अत्यधिक तथ्य वाला जावा कोड नहीं है)।

हालांकि, मैं डेटाबेस सेट प्रसंस्करण की शक्ति को पहचानता हूं। जब उचित रूप से उपयोग किया जाता है, तो एसक्यूएल बहुत कम कोड के साथ कुछ अविश्वसनीय रूप से शक्तिशाली सामान कर सकता है। तो, मैं डेटाबेस में रहने वाले कुछ सेट-आधारित लॉजिक के साथ ठीक हूं, भले ही मैं यूनिट परीक्षण करने के लिए जो कुछ भी कर सकता हूं, वह अभी भी करूँगा।

एक संबंधित नोट पर, ऐसा लगता है कि बहुत लंबा और प्रक्रियात्मक डेटाबेस कोड अक्सर किसी और चीज का लक्षण होता है, और मुझे लगता है कि इस तरह के कोड को प्रदर्शन हिट किए बिना टेस्टेबल कोड में परिवर्तित किया जा सकता है। सिद्धांत यह है कि ऐसा कोड अक्सर बैच प्रक्रियाओं का प्रतिनिधित्व करता है जो समय-समय पर बड़ी मात्रा में डेटा संसाधित करते हैं। यदि इन बैच प्रक्रियाओं को रीयल-टाइम व्यवसाय तर्क के छोटे हिस्सों में परिवर्तित किया जाना था जो इनपुट डेटा बदलते समय चलता है, तो यह तर्क प्रदर्शन हिट किए बिना मध्य-स्तर (जहां इसका परीक्षण किया जा सकता है) पर चलाया जा सकता है (क्योंकि काम वास्तविक समय में छोटे हिस्सों में किया जाता है)। दुष्प्रभाव के रूप में, यह बैच प्रक्रिया त्रुटि प्रबंधन की लंबी प्रतिक्रिया-लूप को भी समाप्त करता है। बेशक यह दृष्टिकोण सभी मामलों में काम नहीं करेगा, लेकिन यह कुछ में काम कर सकता है। इसके अलावा, अगर आपके सिस्टम में ऐसे अवांछित बैच प्रसंस्करण डेटाबेस कोड हैं, तो मोक्ष की राह लंबी और कठिन हो सकती है। YMMV।

0
जोड़ा
QAIndia
QAIndia
160 प्रतिभागियों की

QA India ! Unite Here we share job postings , prepare for interviews and share tips/techniques in QA. Please follow following guideline while sharing any job ... QA job # location : # title Company : Title : Requirement: Responsibility: Apply: