Answer questions in 200 words or less APA site work
Developers can spend much time in making database and program modifications to improve or expand system functionality. Explain some of the steps you would take in testing modifications.
RespondAnswer questions in 200 words or less APA site work
Software testing is essential to production and release of quality software that meets all design requirements. The Software Testing Life Cycle (STLC) can differ between organizations, but most all should include a static then dynamic testing phase. Static testing consists of a thorough review of design requirements and whether or not the software produced meets those requirements. The static review should be a formal meeting between QA personnel and the developers. Any discrepancies or corrections should be documented. Once static testing is completed, dynamic testing can begin.
Dynamic testing begins by first defining the test scope. Scope can include such items as which and how many physical machines will be used, the test duration, and which modules or screens to apply. Once test scope is defined, test cases and scenarios and be ran on the new software and hardware. If possible, it is better is QA and development teams were two separate interties to prevent a conflict of interest. All bugs and subsequent corrections are documented and applied. This cycle is repeated until the test lead deems that the software is good enough and that it meets all criteria.
Another point I've learned from dealing with configuration control. It is often useful to document more than just what changed, but also why changes occurred. Recording the thinking behind why a product was changed can prevent repetition of mistakes and aid in future debugging.
Khanduja, J. (2008, August 14). Twelve essential Steps of Software Testing Life Cycle (STLC). Retrieved from Tech Target: https://itknowledgeexchange.techtarget.com/quality-assurance/twelve-essential-steps-of-software-testing-life-cycle-stlc/
RespondAnswer questions in 200 words or less APA site work
One of the big thing that our book talks about is making sure that any stored unit dependencies are resolved when a referenced object inside of the stored unit is modified. For example, when a procedure calls a function, the function is the referred object and the procedure is the dependent object (Casteel, 2013). This is because the procedure depends on the function existing and running properly. If a change is made to the function, the procedure is labelled as invalid in the USER_OBJECTS and must either be manually recompiled or is automatically compiled when it is executed again. It's generally better to manually recompile a dependent object as runtime errors may occur if it is left to be recompiled automatically. It's important to note that dependencies can be direct or indirect. An indirect dependency involves references to database objects that have dependencies to other objects.
Another practice that I endorse is producing unit tests to automate the testing of stored units. "Unit testing refers to the process of testing individual subprograms for correctness, as opposed to overall application testing." (Feuerstein, 2015). The peace of mind of modifying a stored unit and running all of the unit tests to make sure that no side-effects were introduced is invaluable. SQL Developer provides tools for unit testing, and there are other frameworks available, such as the utPLSQL project found at (https://utplsql.sourceforge.net/). Unit testing involves testing subprograms of a larger application. If the tests pass, then there's less of chance that the application will fail.
References
Casteel, J. (2013). Oracle 11g: PL/SQL Programming. Boston, MA: Course Technology.
Feuerstein, S. (2015, March 11). Steven Feuerstein on Oracle PL/SQL: Recommendations for unit testing PL/SQL programs. Retrieved from https://stevenfeuersteinonplsql.blogspot.com/2015/03/recommendations-for-unit-testing-plsql.html
RespondAnswer questions in 200 words or less APA site work
Good points made by both Johnny and Jason on the Software Testing Life Cycle and Unit tests.
As a database administrator I would propose the creation of separate test, pre-production and production systems. In reality we more often than not make changes to an existing system so this requires a staged testing and deployment process. Developers upload unit tested modifications of their work to the test system. The test people can then perform tests on this system as a whole. Once the system has reached a level of maturity it is copied to the pre-production system. It is on this system that key users can perform usability tests. On this system we are not only checking if the software is correct but also that performance under acceptable under real load and user interface changes acceptable to users. Once these tests have been performed we can plan a deployment to the production system.
As the person responsible for the database you should perform some object dependency checking. Direct dependencies can be checked using the USER_OBJECTS in the data dictionary while Casteel demonstrates a method for checking indirect dependencies using a dependency tree utility (2013,p.294).
References
Casteel, J. (2013). Oracle 11g: PL/SQL Programming. Boston, MA: Course Technology.
All current posts have made some excellent suggestions for properly testing and implementing system modifications. One of the articles I stumbled across mentions 6 different tests that can be used against a system: unit testing, functional testing, system testing, regression testing, system integration testing, and acceptance testing (TechTarget, 2016). Jason already covered unit testing in his post. Functional testing is essentially black box testing, where knowledge of the system is not required but testing still reveals whether or not system functionality requirements are met. This is similar to the static testing mentioned by Johnny in his post. System testing and system integration testing can reveal issues with hardware/software interoperability such as component or subsystem issues. Acceptance testing measures how receptive the end users are of the system and any modifications that have been made, similar to the usability testing described by Ian. Finally, regression testing serves to identify any introduced bugs or functionality changes that may have been made. This can be difficult to conduct depending on how far the modifications reach (TechTarget, 2016).
I've had a little experience testing updates and modifications on several production systems. None of the systems I work with directly experience significant loads, so setting up some virtual space for testing offline usually works well. Pre-production testing seems to work fairly well too. From my experience so far, it seems that user acceptance is the most difficult part of testing/implementing modifications or changes.
Reference
TechTarget (2016). Six functional tests to ensure software quality. Retrieved from:https://searchsoftwarequality.techtarget.com/report/Six-functional-tests-to-ensure-software-quality
Answer questions in 200 words or less APA site work
Oracle give the user many ways to access the information in the data dictionary. What role does the data dictionary play in storing information regarding packages, privileges, and object dependencies? Provide helpful data dictionary views in your answer.
Answer questions in 200 words or less APA site work
The data dictionary provides a wealth of information to enable the administrator or developer find information about the current packages, privileges and object dependencies in the database.
The USER_OBJECTS view provides information on the status of objects in the database. For example, this can be used to display the status of packages (Casteel, 2013, p.277).
SELECT object_name, object_type, status
FROM USER_OBJECTS
WHERE object_type LIKE '%PACKAGE%';
There are a number of views that provide information pertaining to privileges. These include (Casteel, 2013, p.312):
• SESSION_PRIVS, shows all privileges
• SESSION_ROLES, shows all roles granted
• USER_SYS_PRIVS, shows only direct privileges
• USER_ROLE_PRIVS, shows only direct roles granted
The USER_DEPENDENCIES view provides information on direct object dependencies. You can use this view to list the dependencies of an object. This is particularly useful as it is not always immediately obvious what other objects an object references due to the use of synonym's etc.(Casteel, 2013, p.292).
References
Casteel, J. (2013). Oracle 11g: PL/SQL Programming. Boston, MA: Course Technology.
Answer questions in 200 words or less APA site work
The data dictionary stores very useful information in relation to packages, privileges, and object dependencies. This gives database users a method for locating whatever information they may need. Packages that exist in the database can be found via USER_OBJECTS data dictionary view. As Ian mentioned in his post, this can be conducted via a SELECT statement FROM USER_OBJECTS. The data dictionary views for privileges are SESSION_PRIVS, SESSION_ROLES, USER_SYS_PRIVS, and USER_ROLE_PRIVS. SESSION_PRIVS contains direct and inderect schema privileges. SESSION_ROLES produces all of the roles which have been granted to the schema. USER_SYS_PRIVS produces only direct schema privileges. USER_ROLE_PRIVS produces direct roles that have been granted to the schema. Finally, the USER_DEPENDENCIES data dictionary view will provide object name, type, referenced schema, references object name, referenced object type, the name of a link when used, the schema id, and the type of dependency (Casteel, 2013, p. 276-312).
Reference
Casteel, J. (2013). Oracle 11g: PL/SQL Programming (2nd ed.). Boston, MA: Course Technology.
Answer questions in 200 words or less APA site work
Views ALL_DEPENDENCIES can be used to see dependencies between many objects of interest including: triggers, functions, packages, and package bodies. Related views are DBA_DEPENDENCIES and USER_DEPENDENCIES. DBA_DEPENDENCIES is used to view all database dependencies while USER_DEPENDENCIES view is limited to the current user scope.
Reports on object dependency can be generated by combining DBA_DEPENDENCIES with other DBA level views and tables. DBA_DEPENDENCIES can be queried the same as any other table in order to find reference dependencies. Along with SELECT statements, DDL can be used to ADD, DROP, and modify how objects interact with the database and each other.
Oracle.(2003). ALL_DEPENDENCIES. Retrieved from Oracle 10g Database Reference: https://docs.oracle.com/cd/B12037_01/server.101/b10755/statviews_1041.htm#i1576452
Ozturk, T. H. (2011, July 31). How to analyze Object Dependency? Retrieved from TalipHakanOzturk's ORACLE BLOG: https://taliphakanozturken.wordpress.com/tag/dba_dependencies/